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


#define SWIG_VERSION 0x040400
#define SWIGPYTHON
#define SWIG_DIRECTORS
#define SWIG_PYTHON_DIRECTOR_NO_VTABLE

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

#if defined(__cplusplus) && __cplusplus >=201103L
# define SWIG_NOEXCEPT noexcept
#else
# define SWIG_NOEXCEPT throw()
#endif 

/* -----------------------------------------------------------------------------
 * swigcompat.swg
 *
 * Macros to provide support compatibility with older C and C++ standards.
 *
 * Note that SWIG expects __cplusplus to be defined to the appropriate C++ standard.
 * MSVC users are urged to check and examine the /Zc:__cplusplus compiler option.
 * See https://learn.microsoft.com/en-us/cpp/build/reference/zc-cplusplus.
 * ----------------------------------------------------------------------------- */

/* C99 and C++11 should provide snprintf, but define SWIG_NO_SNPRINTF
 * if you're missing it.
 */
#if ((defined __STDC_VERSION__ && __STDC_VERSION__ >= 199901L) || \
     (defined __cplusplus && __cplusplus >= 201103L) || \
     defined SWIG_HAVE_SNPRINTF) && \
    !defined SWIG_NO_SNPRINTF
# define SWIG_snprintf(O,S,F,A) snprintf(O,S,F,A)
# define SWIG_snprintf2(O,S,F,A,B) snprintf(O,S,F,A,B)
#else
/* Fallback versions ignore the buffer size, but most of our uses either have a
 * fixed maximum possible size or dynamically allocate a buffer that's large
 * enough.
 */
# define SWIG_snprintf(O,S,F,A) sprintf(O,F,A)
# define SWIG_snprintf2(O,S,F,A,B) sprintf(O,F,A,B)
#endif


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

#if !defined(PY_SSIZE_T_CLEAN) && !defined(SWIG_NO_PY_SSIZE_T_CLEAN)
#define PY_SSIZE_T_CLEAN
#endif

#if __GNUC__ >= 7
#pragma GCC diagnostic push
#if defined(__cplusplus) && __cplusplus >=201703L
#pragma GCC diagnostic ignored "-Wregister" /* For python-2.7 headers that use register */
#endif
#endif

#if defined(_DEBUG) && defined(SWIG_PYTHON_INTERPRETER_NO_DEBUG)
/* Use debug wrappers with the Python release dll */

#if defined(_MSC_VER) && _MSC_VER >= 1929
/* Workaround compilation errors when redefining _DEBUG in MSVC 2019 version 16.10 and later
 * See https://github.com/swig/swig/issues/2090 */
# include <corecrt.h>
#endif

# undef _DEBUG
# include <Python.h>
# define _DEBUG 1
#else
# include <Python.h>
#endif


#if __GNUC__ >= 7
#pragma GCC diagnostic pop
#endif

#include <stdio.h>
#include <stdlib.h>

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

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

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

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

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

#ifndef SWIGRUNTIME
# define SWIGRUNTIME SWIGINTERN
#endif

#ifndef SWIGRUNTIMEINLINE
# define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
#endif

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

/* Flags for pointer conversions */
#define SWIG_POINTER_DISOWN        0x1
#define SWIG_CAST_NEW_MEMORY       0x2
#define SWIG_POINTER_NO_NULL       0x4
#define SWIG_POINTER_CLEAR         0x8
#define SWIG_POINTER_RELEASE       (SWIG_POINTER_CLEAR | SWIG_POINTER_DISOWN)

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


/*
   Flags/methods for returning states.

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

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

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

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

   Now you can be more explicit:

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

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

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

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

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

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

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

       int food(double)
       int fooi(int);

   and you call

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

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

#define SWIG_OK                    (0)
/* Runtime errors are < 0 */
#define SWIG_ERROR                 (-1)
/* Errors in range -1 to -99 are in swigerrors.swg (errors for all languages including those not using the runtime) */
/* Errors in range -100 to -199 are language specific errors defined in *errors.swg */
/* Errors < -200 are generic runtime specific errors */
#define SWIG_ERROR_RELEASE_NOT_OWNED (-200)

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

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

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


#include <string.h>

#ifdef __cplusplus
extern "C" {
#endif

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

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

/* Structure to store a type and conversion function used for casting */
typedef struct swig_cast_info {
  swig_type_info         *type;			/* pointer to type that is equivalent to this type */
  swig_converter_func     converter;		/* function to cast the void pointers */
  struct swig_cast_info  *next;			/* pointer to next array of casts | pointer to cast hashed by value */
  unsigned int            value;		/* index of the last valid element in the array | typename hash value */
} swig_cast_info;

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

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

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

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

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

/*
 * Hash function for type name strings, based on maRushPrime1Hash (http://amsoftware.narod.ru/algo2.html)
 */
SWIGRUNTIME unsigned int SWIG_Hash(const char *str, unsigned int len) {
  const unsigned char *data = (const unsigned char *)str;
  unsigned int hash = len, i = 0, k;
  int rem = (int)len;

  while (rem >= (int)sizeof(unsigned int)) {
    k = *(unsigned int *)data;
    k += i++;
    hash ^= k;
    hash *= 171717;
    data += sizeof(unsigned int);
    rem -= sizeof(unsigned int);
  }

  switch (rem) {
    case 3: k = (unsigned int)(data[2]) << 16;
            k |= (unsigned int)(data[1]) << 8;
            k |= (unsigned int)(data[0]);
            k += i++;
            hash ^= k;
            hash *= 171717;
            break;
    case 2: k = (unsigned int)(data[1]) << 8;
            k |= (unsigned int)(data[0]);
            k += i++;
            hash ^= k;
            hash *= 171717;
            break;
    case 1: k = (unsigned int)(data[0]);
            k += i++;
            hash ^= k;
            hash *= 171717;
            break;
  }
  return hash;
}

/*
  Check the typename
*/
SWIGRUNTIME swig_cast_info *
SWIG_TypeCheck(const char *c, swig_type_info *ty) {
  static const unsigned int scan_threshold = 4;
  if (ty) {
    swig_cast_info *head = ty->cast;
    unsigned int hash_value = 0;
    int hashed = 0;

    while (head) {

      if (strcmp(head->type->name, c) == 0) {
        return head;
      }

      if (head->value) {
        swig_cast_info *iter;
        swig_cast_info *last = head + head->value;
        swig_cast_info *first = head + 1;
        int search = 1;

        if (!hashed) {
          if (head->value < scan_threshold) {
            for (iter = first; iter <= last; iter++) {
              if (strcmp(iter->type->name, c) == 0) {
                return iter;
              }
            }
            search = 0;
          } else {
            hashed = 1;
            hash_value = SWIG_Hash(c, (unsigned int)strlen(c));
          }
        }

        if (search) {
          /* Binary search over sorted <'next'|'value'> pairs */
          do {
            iter = first + ((last - first) >> 1);
            if (iter->value < hash_value) {
              first = iter + 1;
            } else if (iter->value == hash_value) {

              if (strcmp(iter->next->type->name, c) == 0) {
                return iter->next;
              }

              /* Hash collision check */
              for (last = iter + 1; last->next && last->value == hash_value; last++) {
                if (strcmp(last->next->type->name, c) == 0) {
                  return last->next;
                }
              }
              for (first = iter - 1; first != head && first->value == hash_value; first--) {
                if (strcmp(first->next->type->name, c) == 0) {
                  return first->next;
                }
              }
              break;
            } else
              last = iter - 1;
          } while (first <= last);
        }
      }
      head = head->next;
    }
  }
  return 0;
}

/*
  Check the type by type address
*/
SWIGRUNTIME swig_cast_info *
SWIG_TypeCheckStruct(const swig_type_info *from, swig_type_info *ty) {
  if (ty) {
    swig_cast_info *head = ty->cast;
    while (head) {
      if (head->type == from) {
        return head;
      }

      if (head->value) {
        swig_cast_info *iter;
        swig_cast_info *last = head + head->value;
        swig_cast_info *first = head + 1;

        /* Binary search over sorted array of casts */
        do {
          iter = first + ((last - first) >> 1);
          if (iter->type < from) {
            first = iter + 1;
          } else if (iter->type == from) {
            return iter;
          } else
            last = iter - 1;
        } while (first <= last);
      }
      head = head->next;
    }
  }
  return 0;
}

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

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

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

/*
  Return the pretty name associated with this type,
  that is an unmangled type name in a form presentable to the user.
*/
SWIGRUNTIME const char *
SWIG_TypePrettyName(const swig_type_info *type) {
  /* The "str" field contains the equivalent pretty names of the
     type, separated by vertical-bar characters.  Choose the last
     name. It should be the most specific; a fully resolved name
     but not necessarily with default template parameters expanded. */
  if (!type) return NULL;
  if (type->str != NULL) {
    const char *last_name = type->str;
    const char *s;
    for (s = type->str; *s; s++)
      if (*s == '|') last_name = s+1;
    return last_name;
  }
  else
    return type->name;
}

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

  while (head) {
    swig_cast_info *cast;
    for (cast = head; (cast - head) <= head->value; cast++) {
      if (!cast->converter) {
        swig_type_info *tc = cast->type;
        if (!tc->clientdata) {
          SWIG_TypeClientData(tc, clientdata);
        }
      }
    }
    head = head->next;
  }
}

SWIGRUNTIME void
SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) {
  SWIG_TypeClientData(ti, clientdata);
  ti->owndata = 1;
}

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

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

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

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

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

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

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

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

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

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

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

#ifdef __cplusplus
}
#endif

/* SWIG Errors applicable to all language modules, values are reserved from -1 to -99 */
#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


#if PY_VERSION_HEX >= 0x03030000 && !defined(SWIG_NO_HEAPTYPES)
#if !defined(SWIG_HEAPTYPES)
#define SWIG_HEAPTYPES
#endif
#endif

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

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

#endif

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

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

#if defined(SWIG_HEAPTYPES)
#if PY_VERSION_HEX < 0x030c0000
#include <structmember.h>
#define Py_READONLY READONLY
#define Py_T_PYSSIZET T_PYSSIZET
#endif
#endif

#include <stddef.h> /* For offsetof */


/* Wrapper around PyUnicode_AsUTF8AndSize - call Py_XDECREF on the returned pbytes when finished with the returned string */
SWIGINTERN const char *
SWIG_PyUnicode_AsUTF8AndSize(PyObject *str, Py_ssize_t *psize, PyObject **pbytes)
{
#if PY_VERSION_HEX >= 0x03030000
# if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x030A0000
  *pbytes = NULL;
  return PyUnicode_AsUTF8AndSize(str, psize);
# else
  const char *chars;
  *pbytes = PyUnicode_AsUTF8String(str);
  chars = *pbytes ? PyBytes_AsString(*pbytes) : NULL;
  if (chars && psize)
    *psize = PyBytes_Size(*pbytes);
  return chars;
# endif
#else
  char *chars = NULL;
  *pbytes = NULL;
  PyString_AsStringAndSize(str, &chars, psize);
  return chars;
#endif
}

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

#define SWIG_RUNTIME_MODULE "swig_runtime_data" SWIG_RUNTIME_VERSION

/* SWIGPY_USE_CAPSULE is no longer used within SWIG itself, but some user interface files check for it. */
# define SWIGPY_USE_CAPSULE
#ifdef SWIGPYTHON_BUILTIN
# define SWIGPY_CAPSULE_ATTR_NAME "type_pointer_capsule_builtin" SWIG_TYPE_TABLE_NAME
#else
# define SWIGPY_CAPSULE_ATTR_NAME "type_pointer_capsule" SWIG_TYPE_TABLE_NAME
#endif
#define SWIGPY_CAPSULE_NAME SWIG_RUNTIME_MODULE "." SWIGPY_CAPSULE_ATTR_NAME

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

#if defined(Py_LIMITED_API)
# define PyTuple_GET_ITEM PyTuple_GetItem
/* Note that PyTuple_SetItem() has different semantics from PyTuple_SET_ITEM as it decref's the original tuple item, so in general they cannot be used
  interchangeably. However in SWIG-generated code PyTuple_SET_ITEM is only used with newly initialized tuples without any items and for them this does work. */
# define PyTuple_SET_ITEM PyTuple_SetItem
# define PyTuple_GET_SIZE PyTuple_Size
# define PyCFunction_GET_FLAGS PyCFunction_GetFlags
# define PyCFunction_GET_FUNCTION PyCFunction_GetFunction
# define PyCFunction_GET_SELF PyCFunction_GetSelf
# define PyList_GET_ITEM PyList_GetItem
# define PyList_SET_ITEM PyList_SetItem
# define PySliceObject PyObject
#endif

/* Increment and Decrement wrappers - for portability when using the stable abi and for performance otherwise */
#ifdef Py_LIMITED_API
# define SWIG_Py_INCREF Py_IncRef
# define SWIG_Py_XINCREF Py_IncRef
# define SWIG_Py_DECREF Py_DecRef
# define SWIG_Py_XDECREF Py_DecRef
#else
# define SWIG_Py_INCREF Py_INCREF
# define SWIG_Py_XINCREF Py_XINCREF
# define SWIG_Py_DECREF Py_DECREF
# define SWIG_Py_XDECREF Py_XDECREF
#endif

#if PY_VERSION_HEX >= 0x03000000
#if PY_VERSION_HEX < 0x030d00a6
SWIGINTERN PyObject *
SWIG_PyType_GetFullyQualifiedName(PyTypeObject *type) {
  PyObject *result = NULL;
  PyObject *qualname = PyObject_GetAttrString((PyObject *)type, "__qualname__");
  if (qualname) {
    PyObject *mod = PyObject_GetAttrString((PyObject *)type, "__module__");
    if (mod) {
      if (PyUnicode_Check(mod) && PyUnicode_CompareWithASCIIString(mod, "builtins") && PyUnicode_CompareWithASCIIString(mod, "__main__")) {
        result = PyUnicode_FromFormat("%U%c%U", mod, '.', qualname);
        SWIG_Py_DECREF(qualname);
      } else {
        result = qualname;
      }
      SWIG_Py_DECREF(mod);
    } else {
      result = qualname;
    }
  }

  return result;
}
#else
# define SWIG_PyType_GetFullyQualifiedName PyType_GetFullyQualifiedName
#endif
#endif

/* gh-114329 added PyList_GetItemRef() to Python 3.13.0a4 */
#if PY_VERSION_HEX < 0x030d00a4
SWIGINTERN PyObject *
SWIG_PyList_GetItemRef(PyObject *op, Py_ssize_t index) {
  PyObject *item = PyList_GetItem(op, index);
  Py_XINCREF(item);
  return item;
}
#else
# define SWIG_PyList_GetItemRef PyList_GetItemRef
#endif

/* gh-106004 added PyDict_GetItemRef() and PyDict_GetItemStringRef() to Python 3.13.0a1
   functions are renamed here for compatibility with abi3audit */
#if PY_VERSION_HEX < 0x030d00a1
SWIGINTERN int
SWIG_PyDict_GetItemRef(PyObject *mp, PyObject *key, PyObject **result) {
#if PY_VERSION_HEX >= 0x03000000
  PyObject *item = PyDict_GetItemWithError(mp, key);
#else
  PyObject *item = _PyDict_GetItemWithError(mp, key);
#endif
  if (item != NULL) {
    *result = (PyObject *)(item);
    SWIG_Py_INCREF(*result);
    return 1;
  }
  if (!PyErr_Occurred()) {
    *result = NULL;
    return 0;
  }
  *result = NULL;
  return -1;
}

SWIGINTERN int
SWIG_PyDict_GetItemStringRef(PyObject *mp, const char *key, PyObject **result) {
  int res;
#if PY_VERSION_HEX >= 0x03000000
  PyObject *key_obj = PyUnicode_FromString(key);
#else
  PyObject *key_obj = PyString_FromString(key);
#endif
  if (key_obj == NULL) {
    *result = NULL;
    return -1;
  }
  res = SWIG_PyDict_GetItemRef(mp, key_obj, result);
  Py_DECREF(key_obj);
  return res;
}
#else
# define SWIG_PyDict_GetItemRef PyDict_GetItemRef
# define SWIG_PyDict_GetItemStringRef PyDict_GetItemStringRef
#endif

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

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


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

  if (PyErr_Occurred())
    PyErr_Fetch(&type, &value, &traceback);
  if (value) {
    PyObject *old_str = PyObject_Str(value);
    PyObject *bytes = NULL;
    const char *tmp = SWIG_PyUnicode_AsUTF8AndSize(old_str, NULL, &bytes);
    PyErr_Clear();
    SWIG_Py_XINCREF(type);
    if (tmp)
      PyErr_Format(type, "%s %s", tmp, mesg);
    else
      PyErr_Format(type, "%s", mesg);
    SWIG_Py_XDECREF(bytes);
    SWIG_Py_DECREF(old_str);
    SWIG_Py_DECREF(value);
  } else {
    PyErr_SetString(PyExc_RuntimeError, mesg);
  }
}

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

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

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

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

#ifdef __cplusplus
extern "C" {
#endif

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

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

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

#ifdef __cplusplus
}
#endif


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

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

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

/* Common SWIG API */

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

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

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

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

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

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

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

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


/* Runtime API */

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

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

/* Runtime API implementation */

/* Error manipulation */

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

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

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

/* Set a constant value */

#if defined(SWIGPYTHON_BUILTIN)

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

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

#else

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

#endif

/* SWIG runtime data Python module */
static PyObject *Swig_runtime_data_module_global = NULL;

/* Create/obtain the single swig_runtime_data module which is used across different SWIG generated modules */
SWIGINTERN PyObject *
SWIG_runtime_data_module(void) {
  if (!Swig_runtime_data_module_global) {
#if PY_VERSION_HEX >= 0x030d0000
    /* free-threading note: the GIL is always enabled when this function is first called
       by SWIG_init, so there's no risk of race conditions */
    Swig_runtime_data_module_global = PyImport_AddModuleRef(SWIG_RUNTIME_MODULE);
#elif PY_VERSION_HEX >= 0x03000000
    Swig_runtime_data_module_global = PyImport_AddModule(SWIG_RUNTIME_MODULE);
    SWIG_Py_XINCREF(Swig_runtime_data_module_global);
#else
    static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} }; /* Sentinel */
    Swig_runtime_data_module_global = Py_InitModule(SWIG_RUNTIME_MODULE, swig_empty_runtime_method_table);
    SWIG_Py_XINCREF(Swig_runtime_data_module_global);
#endif
  }
  assert(Swig_runtime_data_module_global);
  return Swig_runtime_data_module_global;
}

/* Append a value to the result obj */
SWIGINTERN PyObject*
SWIG_Python_AppendOutput(PyObject* result, PyObject* obj, int is_void) {
  if (!result) {
    result = obj;
  } else if (result == Py_None && is_void) {
    SWIG_Py_DECREF(result);
    result = obj;
  } else {
    if (!PyList_Check(result)) {
      PyObject *o2 = result;
      result = PyList_New(1);
      if (result) {
        PyList_SET_ITEM(result, 0, o2);
      } else {
        SWIG_Py_DECREF(obj);
        return o2;
      }
    }
    PyList_Append(result,obj);
    SWIG_Py_DECREF(obj);
  }
  return result;
}

/* Unpack the argument tuple */

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

SWIGINTERN int
SWIG_Python_CheckNoKeywords(PyObject *kwargs, const char *name) {
  int no_kwargs = 1;
  if (kwargs) {
    assert(PyDict_Check(kwargs));
    if (PyDict_Size(kwargs) > 0) {
      PyErr_Format(PyExc_TypeError, "%s() does not take keyword arguments", name);
      no_kwargs = 0;
    }
  }
  return no_kwargs;
}

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

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

#ifdef __cplusplus
extern "C" {
#endif

/* Python-specific SWIG API */
#define SWIG_newvarlink()                             SWIG_Python_newvarlink()
#define SWIG_addvarlink(p, name, get_attr, set_attr)  SWIG_Python_addvarlink(p, name, get_attr, set_attr)
#define SWIG_InstallConstants(d, constants)           SWIG_Python_InstallConstants(d, constants)
 
/* -----------------------------------------------------------------------------
 * global variable support code.
 * ----------------------------------------------------------------------------- */
 
typedef struct swig_globalvar {   
  char       *name;                  /* Name of global variable */
  PyObject *(*get_attr)(void);       /* Return the current value */
  int       (*set_attr)(PyObject *); /* Set the value */
  struct swig_globalvar *next;
} swig_globalvar;

typedef struct swig_varlinkobject {
  PyObject_HEAD
  swig_globalvar *vars;
} swig_varlinkobject;

SWIGINTERN PyObject *
SwigVarLink_repr(PyObject *SWIGUNUSEDPARM(v)) {
#if PY_VERSION_HEX >= 0x03000000
  return PyUnicode_InternFromString("<Swig global variables>");
#else
  return PyString_FromString("<Swig global variables>");
#endif
}

SWIGINTERN PyObject *
SwigVarLink_str(PyObject *o) {
  swig_varlinkobject *v = (swig_varlinkobject *) o;
#if PY_VERSION_HEX >= 0x03000000
  PyObject *str = PyUnicode_InternFromString("(");
  PyObject *tail;
  PyObject *joined;
  swig_globalvar *var;
  for (var = v->vars; var; var=var->next) {
    tail = PyUnicode_FromString(var->name);
    joined = PyUnicode_Concat(str, tail);
    SWIG_Py_DECREF(str);
    SWIG_Py_DECREF(tail);
    str = joined;
    if (var->next) {
        tail = PyUnicode_InternFromString(", ");
        joined = PyUnicode_Concat(str, tail);
        SWIG_Py_DECREF(str);
        SWIG_Py_DECREF(tail);
        str = joined;
    }
  }
  tail = PyUnicode_InternFromString(")");
  joined = PyUnicode_Concat(str, tail);
  SWIG_Py_DECREF(str);
  SWIG_Py_DECREF(tail);
  str = joined;
#else
  PyObject *str = PyString_FromString("(");
  swig_globalvar *var;
  for (var = v->vars; var; var=var->next) {
    PyString_ConcatAndDel(&str,PyString_FromString(var->name));
    if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
  }
  PyString_ConcatAndDel(&str,PyString_FromString(")"));
#endif
  return str;
}

SWIGINTERN void
SwigVarLink_dealloc(PyObject *o) {
  swig_varlinkobject *v = (swig_varlinkobject *) o;
  swig_globalvar *var = v->vars;
  while (var) {
    swig_globalvar *n = var->next;
    free(var->name);
    free(var);
    var = n;
  }
}

SWIGINTERN PyObject *
SwigVarLink_getattr(PyObject *o, char *n) {
  swig_varlinkobject *v = (swig_varlinkobject *) o;
  PyObject *res = NULL;
  swig_globalvar *var = v->vars;
  while (var) {
    if (strcmp(var->name,n) == 0) {
      res = (*var->get_attr)();
      break;
    }
    var = var->next;
  }
  if (res == NULL && !PyErr_Occurred()) {
    PyErr_Format(PyExc_AttributeError, "Unknown C global variable '%s'", n);
  }
  return res;
}

SWIGINTERN int
SwigVarLink_setattr(PyObject *o, char *n, PyObject *p) {
  swig_varlinkobject *v = (swig_varlinkobject *) o;
  int res = 1;
  swig_globalvar *var = v->vars;
  while (var) {
    if (strcmp(var->name,n) == 0) {
      res = (*var->set_attr)(p);
      break;
    }
    var = var->next;
  }
  if (res == 1 && !PyErr_Occurred()) {
    PyErr_Format(PyExc_AttributeError, "Unknown C global variable '%s'", n);
  }
  return res;
}

SWIGINTERN PyTypeObject*
SwigVarLink_TypeOnce(void) {
  static char SwigVarLink_doc[] = "Swig variable link object";
#ifndef SWIG_HEAPTYPES
  static PyTypeObject varlink_type;
  static int type_init = 0;
  if (!type_init) {
    const PyTypeObject tmp = {
#if PY_VERSION_HEX >= 0x03000000
      PyVarObject_HEAD_INIT(NULL, 0)
#else
      PyObject_HEAD_INIT(NULL)
      0,                                  /* ob_size */
#endif
      SWIG_RUNTIME_MODULE ".SwigVarLink", /* tp_name */
      sizeof(swig_varlinkobject),         /* tp_basicsize */
      0,                                  /* tp_itemsize */
      (destructor) SwigVarLink_dealloc,   /* tp_dealloc */
#if PY_VERSION_HEX < 0x030800b4
      (printfunc)0,                       /* tp_print */
#else
      (Py_ssize_t)0,                      /* tp_vectorcall_offset */
#endif
      (getattrfunc) SwigVarLink_getattr,  /* tp_getattr */
      (setattrfunc) SwigVarLink_setattr,  /* tp_setattr */
      0,                                  /* tp_compare */
      (reprfunc) SwigVarLink_repr,        /* tp_repr */
      0,                                  /* tp_as_number */
      0,                                  /* tp_as_sequence */
      0,                                  /* tp_as_mapping */
      0,                                  /* tp_hash */
      0,                                  /* tp_call */
      (reprfunc) SwigVarLink_str,         /* tp_str */
      0,                                  /* tp_getattro */
      0,                                  /* tp_setattro */
      0,                                  /* tp_as_buffer */
      0,                                  /* tp_flags */
      SwigVarLink_doc,                    /* tp_doc */
      0,                                  /* tp_traverse */
      0,                                  /* tp_clear */
      0,                                  /* tp_richcompare */
      0,                                  /* tp_weaklistoffset */
      0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
      0,                                  /* tp_del */
      0,                                  /* tp_version_tag */
#if PY_VERSION_HEX >= 0x03040000
      0,                                  /* tp_finalize */
#endif
#if PY_VERSION_HEX >= 0x03080000
      0,                                  /* tp_vectorcall */
#endif
#if (PY_VERSION_HEX >= 0x03080000) && (PY_VERSION_HEX < 0x03090000)
      0,                                  /* tp_print */
#endif
#if PY_VERSION_HEX >= 0x030c0000
      0,                                  /* tp_watched */
#endif
#if PY_VERSION_HEX >= 0x030d00a4
      0,                                  /* tp_versions_used */
#endif
#ifdef COUNT_ALLOCS
      0,                                  /* tp_allocs */
      0,                                  /* tp_frees */
      0,                                  /* tp_maxalloc */
      0,                                  /* tp_prev */
      0                                   /* tp_next */
#endif
    };
    PyObject *runtime_data_module = SWIG_runtime_data_module();
    varlink_type = tmp;
    type_init = 1;
    if (PyType_Ready(&varlink_type) < 0)
      return NULL;
    if (PyModule_AddObject(runtime_data_module, "SwigVarLink", (PyObject *)&varlink_type) == 0)
      SWIG_Py_INCREF((PyObject *)&varlink_type);
  }
  return &varlink_type;
#else
  PyType_Slot slots[] = {
    { Py_tp_dealloc, (void *)SwigVarLink_dealloc },
    { Py_tp_repr, (void *)SwigVarLink_repr },
    { Py_tp_getattr, (void *)SwigVarLink_getattr },
    { Py_tp_setattr, (void *)SwigVarLink_setattr },
    { Py_tp_str, (void *)SwigVarLink_str },
    { Py_tp_doc, (void *)SwigVarLink_doc },
    { 0, NULL }
  };
  PyType_Spec spec = {
    SWIG_RUNTIME_MODULE ".SwigVarLink",
    sizeof(swig_varlinkobject),
    0,
    Py_TPFLAGS_DEFAULT,
    slots
  };
  PyObject *pytype = PyType_FromSpec(&spec);
  PyObject *runtime_data_module = SWIG_runtime_data_module();
  if (pytype && PyModule_AddObject(runtime_data_module, "SwigVarLink", pytype) == 0)
    SWIG_Py_INCREF(pytype);
  return (PyTypeObject *)pytype;
#endif
}

SWIGRUNTIME PyTypeObject*
SwigVarLink_Type(void) {
  static PyTypeObject *SWIG_STATIC_POINTER(type) = SwigVarLink_TypeOnce();
  return type;
}

/* Create a variable linking object for use later */
SWIGINTERN PyObject *
SWIG_Python_newvarlink(void) {
  swig_varlinkobject *result = PyObject_New(swig_varlinkobject, SwigVarLink_Type());
  if (result) {
    result->vars = 0;
  }
  return ((PyObject*) result);
}

SWIGINTERN void 
SWIG_Python_addvarlink(PyObject *p, const char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
  swig_varlinkobject *v = (swig_varlinkobject *) p;
  swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
  if (gv) {
    size_t size = strlen(name)+1;
    gv->name = (char *)malloc(size);
    if (gv->name) {
      memcpy(gv->name, name, size);
      gv->get_attr = get_attr;
      gv->set_attr = set_attr;
      gv->next = v->vars;
    }
  }
  v->vars = gv;
}


static PyObject *Swig_Globals_global = NULL;
  
SWIGINTERN PyObject *
SWIG_globals(void) {
  if (Swig_Globals_global == NULL) {
    Swig_Globals_global = SWIG_newvarlink();
  }
  return Swig_Globals_global;
}

#ifdef __cplusplus
}
#endif

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

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

#define SWIG_POINTER_IMPLICIT_CONV  (SWIG_POINTER_DISOWN   << 1)

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

#ifdef __cplusplus
extern "C" {
#endif

/* The python void return value */

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

/* SwigPyClientData */

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

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

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


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

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

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

typedef struct {
  PyObject_HEAD
  void *ptr;
  swig_type_info *ty;
  int own;
  PyObject *next;
  PyObject *swigdict;
  PyObject *weakreflist;
} SwigPyObject;


#ifdef SWIGPYTHON_BUILTIN

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

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

  SWIG_Py_XINCREF(sobj->swigdict);
  return sobj->swigdict;
}

#endif

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

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

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

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

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

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

SWIGRUNTIME int
SwigPyObject_compare(PyObject *v, PyObject *w)
{
  /* tp_compare is only called when both objects have the same type, so
   * the casts are guaranteed to be ok. */
  void *i = ((SwigPyObject *)v)->ptr;
  void *j = ((SwigPyObject *)w)->ptr;
  return (i < j) ? -1 : ((i > j) ? 1 : 0);
}

SWIGRUNTIMEINLINE int SwigPyObject_Check(PyObject *);

/* Added for Python 3.x, would it also be useful for Python 2.x? */
SWIGRUNTIME PyObject*
SwigPyObject_richcompare(PyObject *v, PyObject *w, int op)
{
  PyObject* res = NULL;
  if (!PyErr_Occurred()) {
    /* Per https://docs.python.org/3/c-api/typeobj.html#c.PyTypeObject.tp_richcompare
     * the first argument is guaranteed to be an instance of SwigPyObject, but the
     * second is not, so we typecheck that one. */
    if ((op != Py_EQ && op != Py_NE) || !SwigPyObject_Check(w)) {
      SWIG_Py_INCREF(Py_NotImplemented);
      return Py_NotImplemented;
    }
    res = PyBool_FromLong( (SwigPyObject_compare(v, w)==0) == (op == Py_EQ) ? 1 : 0);
  }
  return res;
}


SWIGRUNTIME PyTypeObject* SwigPyObject_TypeOnce(void);

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

SWIGRUNTIMEINLINE int
SwigPyObject_Check(PyObject *op) {
  PyTypeObject *target_tp = SwigPyObject_Type();
  PyTypeObject *op_type = Py_TYPE(op);
#ifdef SWIGPYTHON_BUILTIN
  /* Only builtin types have SwigPyObject as a base type */
  return PyType_IsSubtype(op_type, target_tp);
#else
  /* Check for an exact match to SwigPyObject */
  if (op_type == target_tp) {
    return 1;
  } else {
    /* Fallback for multiple modules */
#if PY_VERSION_HEX >= 0x03000000
    int cmp;
    PyObject *tpname = SWIG_PyType_GetFullyQualifiedName(op_type);
    if (!tpname)
      return 0;
    cmp = PyUnicode_CompareWithASCIIString(tpname, SWIG_RUNTIME_MODULE ".SwigPyObject");
    SWIG_Py_DECREF(tpname);
    return cmp == 0;
#else
    return strcmp(op_type->tp_name, SWIG_RUNTIME_MODULE ".SwigPyObject") == 0;
#endif
  }
#endif
}

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

static PyObject* Swig_Capsule_global = NULL;

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

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

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

      PyErr_Restore(type, value, traceback);

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

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

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

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

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

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

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

SWIGRUNTIME PyTypeObject*
SwigPyObject_TypeOnce(void) {
  static char SwigPyObject_doc[] = "Swig object holding a C/C++ pointer";
#ifndef SWIG_HEAPTYPES
  static PyNumberMethods SwigPyObject_as_number = {
    (binaryfunc)0, /*nb_add*/
    (binaryfunc)0, /*nb_subtract*/
    (binaryfunc)0, /*nb_multiply*/
    /* nb_divide removed in Python 3 */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc)0, /*nb_divide*/
#endif
    (binaryfunc)0, /*nb_remainder*/
    (binaryfunc)0, /*nb_divmod*/
    (ternaryfunc)0,/*nb_power*/
    (unaryfunc)0,  /*nb_negative*/
    (unaryfunc)0,  /*nb_positive*/
    (unaryfunc)0,  /*nb_absolute*/
    (inquiry)0,    /*nb_nonzero*/
    0,		   /*nb_invert*/
    0,		   /*nb_lshift*/
    0,		   /*nb_rshift*/
    0,		   /*nb_and*/
    0,		   /*nb_xor*/
    0,		   /*nb_or*/
#if PY_VERSION_HEX < 0x03000000
    0,   /*nb_coerce*/
#endif
    (unaryfunc)SwigPyObject_long, /*nb_int*/
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc)SwigPyObject_long, /*nb_long*/
#else
    0, /*nb_reserved*/
#endif
    (unaryfunc)0,                 /*nb_float*/
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc)SwigPyObject_oct,  /*nb_oct*/
    (unaryfunc)SwigPyObject_hex,  /*nb_hex*/
#endif
#if PY_VERSION_HEX >= 0x03050000 /* 3.5 */
    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_matrix_multiply */
#elif PY_VERSION_HEX >= 0x03000000 /* 3.0 */
    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_index, nb_inplace_divide removed */
#else
    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_index */
#endif
  };

  static PyTypeObject swigpyobject_type;
  static int type_init = 0;
  if (!type_init) {
    const PyTypeObject tmp = {
#if PY_VERSION_HEX >= 0x03000000
      PyVarObject_HEAD_INIT(NULL, 0)
#else
      PyObject_HEAD_INIT(NULL)
      0,                                    /* ob_size */
#endif
      SWIG_RUNTIME_MODULE ".SwigPyObject",  /* tp_name */
      sizeof(SwigPyObject),                 /* tp_basicsize */
      0,                                    /* tp_itemsize */
      (destructor)SwigPyObject_dealloc,     /* tp_dealloc */
#if PY_VERSION_HEX < 0x030800b4
      (printfunc)0,                         /* tp_print */
#else
      (Py_ssize_t)0,                        /* tp_vectorcall_offset */
#endif
      (getattrfunc)0,                       /* tp_getattr */
      (setattrfunc)0,                       /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
      0, /* tp_reserved in 3.0.1, tp_compare in 3.0.0 but not used */
#else
      (cmpfunc)SwigPyObject_compare,        /* tp_compare */
#endif
      (reprfunc)SwigPyObject_repr,          /* tp_repr */
      &SwigPyObject_as_number,              /* tp_as_number */
      0,                                    /* tp_as_sequence */
      0,                                    /* tp_as_mapping */
      (hashfunc)0,                          /* tp_hash */
      (ternaryfunc)0,                       /* tp_call */
      0,                                    /* tp_str */
      PyObject_GenericGetAttr,              /* tp_getattro */
      0,                                    /* tp_setattro */
      0,                                    /* tp_as_buffer */
      Py_TPFLAGS_DEFAULT,                   /* tp_flags */
      SwigPyObject_doc,                     /* tp_doc */
      0,                                    /* tp_traverse */
      0,                                    /* tp_clear */
      (richcmpfunc)SwigPyObject_richcompare,/* tp_richcompare */
      offsetof(SwigPyObject, weakreflist),  /* tp_weaklistoffset */
      0,                                    /* tp_iter */
      0,                                    /* tp_iternext */
      SwigPyObject_methods,                 /* tp_methods */
      0,                                    /* tp_members */
      0,                                    /* tp_getset */
      0,                                    /* tp_base */
      0,                                    /* tp_dict */
      0,                                    /* tp_descr_get */
      0,                                    /* tp_descr_set */
      0,                                    /* tp_dictoffset */
      0,                                    /* tp_init */
      0,                                    /* tp_alloc */
      0,                                    /* tp_new */
      0,                                    /* tp_free */
      0,                                    /* tp_is_gc */
      0,                                    /* tp_bases */
      0,                                    /* tp_mro */
      0,                                    /* tp_cache */
      0,                                    /* tp_subclasses */
      0,                                    /* tp_weaklist */
      0,                                    /* tp_del */
      0,                                    /* tp_version_tag */
#if PY_VERSION_HEX >= 0x03040000
      0,                                    /* tp_finalize */
#endif
#if PY_VERSION_HEX >= 0x03080000
      0,                                    /* tp_vectorcall */
#endif
#if (PY_VERSION_HEX >= 0x03080000) && (PY_VERSION_HEX < 0x03090000)
      0,                                    /* tp_print */
#endif
#if PY_VERSION_HEX >= 0x030c0000
      0,                                    /* tp_watched */
#endif
#if PY_VERSION_HEX >= 0x030d00a4
      0,                                    /* tp_versions_used */
#endif
#ifdef COUNT_ALLOCS
      0,                                    /* tp_allocs */
      0,                                    /* tp_frees */
      0,                                    /* tp_maxalloc */
      0,                                    /* tp_prev */
      0                                     /* tp_next */
#endif
    };
    PyObject *runtime_data_module = SWIG_runtime_data_module();
    swigpyobject_type = tmp;
    type_init = 1;
    if (PyType_Ready(&swigpyobject_type) != 0)
      return NULL;
    if (PyModule_AddObject(runtime_data_module, "SwigPyObject", (PyObject *)&swigpyobject_type) == 0)
      SWIG_Py_INCREF((PyObject *)&swigpyobject_type);
  }
  return &swigpyobject_type;
#else
  static PyMemberDef SwigPyObject_members[] = {
      { (char *)"__dictoffset__", Py_T_PYSSIZET, offsetof(SwigPyObject, swigdict), Py_READONLY, NULL },
      { (char *)"__weaklistoffset__", Py_T_PYSSIZET, offsetof(SwigPyObject, weakreflist), Py_READONLY, NULL },
      { NULL, 0, 0, 0, NULL }
  };
  PyType_Slot slots[] = {
    { Py_tp_dealloc, (void *)SwigPyObject_dealloc },
    { Py_tp_repr, (void *)SwigPyObject_repr },
    { Py_tp_getattro, (void *)PyObject_GenericGetAttr },
    { Py_tp_doc, (void *)SwigPyObject_doc },
    { Py_tp_richcompare, (void *)SwigPyObject_richcompare },
    { Py_tp_methods, (void *)SwigPyObject_methods },
    { Py_nb_int, (void *)SwigPyObject_long },
    { Py_tp_members, (void *)SwigPyObject_members },
    { 0, NULL }
  };
  PyType_Spec spec = {
    SWIG_RUNTIME_MODULE ".SwigPyObject",
    sizeof(SwigPyObject),
    0,
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,
    slots
  };
  PyObject *pytype = PyType_FromSpec(&spec);
  PyObject *runtime_data_module = SWIG_runtime_data_module();
#if !defined(Py_LIMITED_API)
/* While this __dictoffset__ is only used with the builtin wrappers, SwigPyObject ought to be
   identical when created for use by proxy class wrappers in case it is shared across multiple modules. */
#if PY_VERSION_HEX < 0x03090000
    /* Workaround as __dictoffset__ and __weaklistoffset__ above are only supported from python-3.9 */
  if (pytype) {
    ((PyTypeObject *)pytype)->tp_dictoffset = offsetof(SwigPyObject, swigdict);
    ((PyTypeObject *)pytype)->tp_weaklistoffset = offsetof(SwigPyObject, weakreflist);
  }
#endif
#endif
  if (pytype && PyModule_AddObject(runtime_data_module, "SwigPyObject", pytype) == 0)
    SWIG_Py_INCREF(pytype);
  return (PyTypeObject *)pytype;
#endif
}

SWIGRUNTIME PyObject *
SwigPyObject_New(void *ptr, swig_type_info *ty, int own)
{
  SwigPyObject *sobj = PyObject_New(SwigPyObject, SwigPyObject_Type());
  if (sobj) {
    sobj->ptr  = ptr;
    sobj->ty   = ty;
    sobj->own  = own;
    sobj->next = 0;
    sobj->swigdict = 0;
    sobj->weakreflist = 0;
    if (own == SWIG_POINTER_OWN) {
      /* Obtain a reference to the Python capsule wrapping the module information, so that the
       * module information is correctly destroyed after all SWIG python objects have been freed
       * by the GC (and corresponding destructors invoked) */
      SWIG_Py_XINCREF(Swig_Capsule_global);
    }
  }
  return (PyObject *)sobj;
}

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

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

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

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

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

SWIGRUNTIME PyTypeObject* SwigPyPacked_TypeOnce(void);

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

SWIGRUNTIMEINLINE int
SwigPyPacked_Check(PyObject *op) {
  PyTypeObject *target_tp = SwigPyPacked_Type();
  PyTypeObject *op_type = Py_TYPE(op);
  /* Check for an exact match to SwigPyPacked */
  if (op_type == target_tp) {
    return 1;
  } else {
    /* Fallback for multiple modules */
#if PY_VERSION_HEX >= 0x03000000
    int cmp;
    PyObject *tpname = SWIG_PyType_GetFullyQualifiedName(op_type);
    if (!tpname)
      return 0;
    cmp = PyUnicode_CompareWithASCIIString(tpname, SWIG_RUNTIME_MODULE ".SwigPyPacked");
    SWIG_Py_DECREF(tpname);
    return cmp == 0;
#else
    return strcmp(op_type->tp_name, SWIG_RUNTIME_MODULE ".SwigPyPacked") == 0;
#endif
  }
}

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

SWIGRUNTIME PyTypeObject*
SwigPyPacked_TypeOnce(void) {
  static char SwigPyPacked_doc[] = "Swig object holding a C/C++ function pointer";
#ifndef SWIG_HEAPTYPES
  static PyTypeObject swigpypacked_type;
  static int type_init = 0;
  if (!type_init) {
    const PyTypeObject tmp = {
#if PY_VERSION_HEX >= 0x03000000
      PyVarObject_HEAD_INIT(NULL, 0)
#else
      PyObject_HEAD_INIT(NULL)
      0,                                    /* ob_size */
#endif
      SWIG_RUNTIME_MODULE ".SwigPyPacked",  /* tp_name */
      sizeof(SwigPyPacked),                 /* tp_basicsize */
      0,                                    /* tp_itemsize */
      (destructor)SwigPyPacked_dealloc,     /* tp_dealloc */
#if PY_VERSION_HEX < 0x030800b4
      (printfunc)0,                         /* tp_print */
#else
      (Py_ssize_t)0,                        /* tp_vectorcall_offset */
#endif
      (getattrfunc)0,                       /* tp_getattr */
      (setattrfunc)0,                       /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
      0, /* tp_reserved in 3.0.1 */
#else
      (cmpfunc)SwigPyPacked_compare,        /* tp_compare */
#endif
      (reprfunc)SwigPyPacked_repr,          /* tp_repr */
      0,                                    /* tp_as_number */
      0,                                    /* tp_as_sequence */
      0,                                    /* tp_as_mapping */
      (hashfunc)0,                          /* tp_hash */
      (ternaryfunc)0,                       /* tp_call */
      (reprfunc)SwigPyPacked_str,           /* tp_str */
      PyObject_GenericGetAttr,              /* tp_getattro */
      0,                                    /* tp_setattro */
      0,                                    /* tp_as_buffer */
      Py_TPFLAGS_DEFAULT,                   /* tp_flags */
      SwigPyPacked_doc,                     /* tp_doc */
      0,                                    /* tp_traverse */
      0,                                    /* tp_clear */
      0,                                    /* tp_richcompare */
      0,                                    /* tp_weaklistoffset */
      0,                                    /* tp_iter */
      0,                                    /* tp_iternext */
      0,                                    /* tp_methods */
      0,                                    /* tp_members */
      0,                                    /* tp_getset */
      0,                                    /* tp_base */
      0,                                    /* tp_dict */
      0,                                    /* tp_descr_get */
      0,                                    /* tp_descr_set */
      0,                                    /* tp_dictoffset */
      0,                                    /* tp_init */
      0,                                    /* tp_alloc */
      0,                                    /* tp_new */
      0,                                    /* tp_free */
      0,                                    /* tp_is_gc */
      0,                                    /* tp_bases */
      0,                                    /* tp_mro */
      0,                                    /* tp_cache */
      0,                                    /* tp_subclasses */
      0,                                    /* tp_weaklist */
      0,                                    /* tp_del */
      0,                                    /* tp_version_tag */
#if PY_VERSION_HEX >= 0x03040000
      0,                                    /* tp_finalize */
#endif
#if PY_VERSION_HEX >= 0x03080000
      0,                                    /* tp_vectorcall */
#endif
#if (PY_VERSION_HEX >= 0x03080000) && (PY_VERSION_HEX < 0x03090000)
      0,                                    /* tp_print */
#endif
#if PY_VERSION_HEX >= 0x030c0000
      0,                                    /* tp_watched */
#endif
#if PY_VERSION_HEX >= 0x030d00a4
      0,                                    /* tp_versions_used */
#endif
#ifdef COUNT_ALLOCS
      0,                                    /* tp_allocs */
      0,                                    /* tp_frees */
      0,                                    /* tp_maxalloc */
      0,                                    /* tp_prev */
      0                                     /* tp_next */
#endif
    };
    PyObject *runtime_data_module = SWIG_runtime_data_module();
    swigpypacked_type = tmp;
    type_init = 1;
    if (PyType_Ready(&swigpypacked_type) != 0)
      return NULL;
    if (PyModule_AddObject(runtime_data_module, "SwigPyPacked", (PyObject *)&swigpypacked_type) == 0)
      SWIG_Py_INCREF((PyObject *)&swigpypacked_type);
  }
  return &swigpypacked_type;
#else
  PyType_Slot slots[] = {
    { Py_tp_dealloc, (void *)SwigPyPacked_dealloc },
    { Py_tp_repr, (void *)SwigPyPacked_repr },
    { Py_tp_str, (void *)SwigPyPacked_str },
    { Py_tp_getattro, (void *)PyObject_GenericGetAttr },
    { Py_tp_doc, (void *)SwigPyPacked_doc },
    { 0, NULL }
  };
  PyType_Spec spec = {
    SWIG_RUNTIME_MODULE ".SwigPyPacked",
    sizeof(SwigPyPacked),
    0,
    Py_TPFLAGS_DEFAULT,
    slots
  };
  PyObject *pytype = PyType_FromSpec(&spec);
  PyObject *runtime_data_module = SWIG_runtime_data_module();
  if (pytype && PyModule_AddObject(runtime_data_module, "SwigPyPacked", pytype) == 0)
    SWIG_Py_INCREF(pytype);
  return (PyTypeObject *)pytype;
#endif
}

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

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

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

static PyObject *Swig_This_global = NULL;

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

/* #define SWIG_PYTHON_SLOW_GETSET_THIS */

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

/* Returns a borrowed reference to the 'this' object */
SWIGRUNTIME SwigPyObject *
SWIG_Python_GetSwigThis(PyObject *pyobj) 
{
  PyObject *obj;

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

#ifdef SWIGPYTHON_BUILTIN
  (void)obj;
  if (PyWeakref_CheckProxy(pyobj)) {
#if PY_VERSION_HEX >= 0x030d0000
    if (PyWeakref_GetRef(pyobj, &pyobj) > 0)
      Py_DECREF(pyobj);
    else
      pyobj = NULL;
#else
    pyobj = PyWeakref_GetObject(pyobj);
#endif
    if (pyobj && SwigPyObject_Check(pyobj))
      return (SwigPyObject*) pyobj;
  }
  return NULL;
#else

  obj = 0;

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

/* Acquire a pointer value */

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

/* Convert a pointer value */

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

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

  res = SWIG_ERROR;

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

/* Convert a function ptr value */

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

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

/* Convert a packed pointer value */

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

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

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

SWIGRUNTIME PyObject* 
SWIG_Python_NewShadowInstance(SwigPyClientData *data, PyObject *swig_this)
{
  PyObject *inst = 0;
  PyObject *newraw = data->newraw;
  if (newraw) {
    inst = PyObject_Call(newraw, data->newargs, NULL);
    if (inst) {
#if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
      PyObject **dictptr = _PyObject_GetDictPtr(inst);
      if (dictptr != NULL) {
        PyObject *dict = *dictptr;
        if (dict == NULL) {
          dict = PyDict_New();
          *dictptr = dict;
        }
        if (dict) {
          PyDict_SetItem(dict, SWIG_This(), swig_this);
        } else{
          SWIG_Py_DECREF(inst);
          inst = 0;
        }
      }
#else
      if (PyObject_SetAttr(inst, SWIG_This(), swig_this) == -1) {
        SWIG_Py_DECREF(inst);
        inst = 0;
      }
#endif
    }
  } else {
#if PY_VERSION_HEX >= 0x03000000
    PyObject *empty_args = PyTuple_New(0);
    if (empty_args) {
      PyObject *empty_kwargs = PyDict_New();
      if (empty_kwargs) {
#ifndef Py_LIMITED_API
        newfunc newfn = ((PyTypeObject *)data->newargs)->tp_new;
#else
        newfunc newfn = (newfunc)PyType_GetSlot((PyTypeObject *)data->newargs, Py_tp_new);
#endif
        inst = newfn((PyTypeObject *)data->newargs, empty_args, empty_kwargs);
        SWIG_Py_DECREF(empty_kwargs);
        if (inst) {
          if (PyObject_SetAttr(inst, SWIG_This(), swig_this) == -1) {
            SWIG_Py_DECREF(inst);
            inst = 0;
          } else {
            PyType_Modified(Py_TYPE(inst));
          }
        }
      }
      SWIG_Py_DECREF(empty_args);
    }
#else
    PyObject *dict = PyDict_New();
    if (dict) {
      PyDict_SetItem(dict, SWIG_This(), swig_this);
      inst = PyInstance_NewRaw(data->newargs, dict);
      SWIG_Py_DECREF(dict);
    }
#endif
  }
  return inst;
}

SWIGRUNTIME int
SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this)
{
#if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
  PyObject **dictptr = _PyObject_GetDictPtr(inst);
  if (dictptr != NULL) {
    PyObject *dict = *dictptr;
    if (dict == NULL) {
      dict = PyDict_New();
      *dictptr = dict;
    }
    if (dict) {
      return PyDict_SetItem(dict, SWIG_This(), swig_this);
    } else{
      return -1;
    }
  }
#endif
  return PyObject_SetAttr(inst, SWIG_This(), swig_this);
} 


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

/* Create a new pointer object */

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

  if (!ptr)
    return SWIG_Py_Void();

  clientdata = type ? (SwigPyClientData *)(type->clientdata) : 0;
  own = (flags & SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0;
  if (clientdata && clientdata->pytype) {
    SwigPyObject *newobj;
    if (flags & SWIG_BUILTIN_TP_INIT) {
      newobj = (SwigPyObject*) self;
      if (newobj->ptr) {
#ifndef Py_LIMITED_API
        allocfunc alloc = clientdata->pytype->tp_alloc;
#else
        allocfunc alloc = (allocfunc)PyType_GetSlot(clientdata->pytype, Py_tp_alloc);
#endif
        PyObject *next_self = alloc(clientdata->pytype, 0);
        while (newobj->next)
	  newobj = (SwigPyObject *) newobj->next;
        newobj->next = next_self;
        newobj = (SwigPyObject *)next_self;
        newobj->swigdict = 0;
        newobj->weakreflist = 0;
      }
    } else {
      newobj = PyObject_New(SwigPyObject, clientdata->pytype);
      if (newobj) {
        newobj->swigdict = 0;
        newobj->weakreflist = 0;
      }
    }
    if (newobj) {
      newobj->ptr = ptr;
      newobj->ty = type;
      newobj->own = own;
      newobj->next = 0;
      return (PyObject*) newobj;
    }
    return SWIG_Py_Void();
  }

  assert(!(flags & SWIG_BUILTIN_TP_INIT));

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

/* Create a new packed object */

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

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

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

static PyObject *Swig_TypeCache_global = NULL;

/* The python cached type query */
SWIGRUNTIME PyObject *
SWIG_Python_TypeCache(void) {
  if (Swig_TypeCache_global == NULL) {
    Swig_TypeCache_global = PyDict_New();
  }
  return Swig_TypeCache_global;
}

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


#if defined(SWIG_REFCNT_DEBUG)
#define SWIG_PYOBJ_REFCNT(OBJ) fprintf(stdout, "" #OBJ " count %ld\n", (OBJ ? Py_REFCNT(OBJ) : 0))
#else
#define SWIG_PYOBJ_REFCNT(OBJ)
#endif

static int interpreter_counter = 0; /* how many (sub-)interpreters are using swig_module's types */

SWIGRUNTIME void
SWIG_Python_DestroyModule(PyObject *obj)
{
  swig_module_info *swig_module = (swig_module_info *) PyCapsule_GetPointer(obj, SWIGPY_CAPSULE_NAME);
  swig_type_info **types = swig_module->types;
  size_t i;
  if (--interpreter_counter != 0) /* another sub-interpreter may still be using the swig_module's types */
    return;
  for (i = 0; i < swig_module->size; ++i) {
    swig_type_info *ty = types[i];
    if (ty->owndata) {
      SwigPyClientData *data = (SwigPyClientData *) ty->clientdata;
      ty->clientdata = 0;
      if (data) SwigPyClientData_Del(data);
    }
  }
  SWIG_PYOBJ_REFCNT(Swig_This_global);
  SWIG_Py_XDECREF(Swig_This_global);
  Swig_This_global = NULL;

  SWIG_PYOBJ_REFCNT(Swig_Globals_global);
  SWIG_Py_XDECREF(Swig_Globals_global);
  Swig_Globals_global = NULL;

  SWIG_PYOBJ_REFCNT(Swig_TypeCache_global);
  SWIG_Py_XDECREF(Swig_TypeCache_global);
  Swig_TypeCache_global = NULL;

  SWIG_PYOBJ_REFCNT(Swig_Capsule_global);
  Swig_Capsule_global = NULL;

  SWIG_PYOBJ_REFCNT(Swig_runtime_data_module_global);
  SWIG_Py_XDECREF(Swig_runtime_data_module_global);
  Swig_runtime_data_module_global = NULL;
}

SWIGRUNTIME void
SWIG_Python_SetModule(swig_module_info *swig_module) {
  PyObject *runtime_data_module = SWIG_runtime_data_module();
  PyObject *pointer = PyCapsule_New((void *) swig_module, SWIGPY_CAPSULE_NAME, SWIG_Python_DestroyModule);
  if (pointer && runtime_data_module) {
    if (PyModule_AddObject(runtime_data_module, SWIGPY_CAPSULE_ATTR_NAME, pointer) == 0) {
      ++interpreter_counter;
      Swig_Capsule_global = pointer;
    } else {
      SWIG_Py_DECREF(pointer);
    }
  } else {
    SWIG_Py_XDECREF(pointer);
  }
}

SWIGRUNTIME swig_type_info *
SWIG_Python_TypeQuery(const char *type)
{
  swig_type_info *descriptor;
  PyObject *cache = SWIG_Python_TypeCache();
  PyObject *obj;
  SWIG_PyDict_GetItemStringRef(cache, type, &obj);
  if (obj) {
    descriptor = (swig_type_info *) PyCapsule_GetPointer(obj, NULL);
  } else {
    swig_module_info *swig_module = SWIG_GetModule(0);
    descriptor = SWIG_TypeQueryModule(swig_module, swig_module, type);
    if (descriptor) {
      obj = PyCapsule_New((void*) descriptor, NULL, NULL);
      if (obj) PyDict_SetItemString(cache, type, obj);
    }
  }
  SWIG_Py_XDECREF(obj);
  return descriptor;
}

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

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

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

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

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

# ifdef Py_USING_UNICODE
  if (PyString_Check(name)) {
    name = PyUnicode_Decode(PyString_AsString(name), PyString_Size(name), NULL, NULL);
    if (!name)
      return -1;
  } else if (!PyUnicode_Check(name))
# else
  if (!PyString_Check(name))
# endif
  {
#if PY_VERSION_HEX >= 0x03000000
    PyObject *tpname = SWIG_PyType_GetFullyQualifiedName(Py_TYPE(name));
    PyErr_Format(PyExc_TypeError, "attribute name must be string, not '%S'", tpname);
    SWIG_Py_DECREF(tpname);
#else
    PyErr_Format(PyExc_TypeError, "attribute name must be string, not '%s'", Py_TYPE(name)->tp_name);
#endif
    return -1;
  } else {
    SWIG_Py_INCREF(name);
  }

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

  descr = _PyType_Lookup(tp, name);
  f = NULL;
  if (descr != NULL)
    f = Py_TYPE(descr)->tp_descr_set;
  if (!f) {
    if (PyString_Check(name)) {
      encoded_name = name;
      SWIG_Py_INCREF(name);
    } else {
      encoded_name = PyUnicode_AsUTF8String(name);
      if (!encoded_name)
        goto done;
    }
#if PY_VERSION_HEX >= 0x03000000
    {
      PyObject *tpname = SWIG_PyType_GetFullyQualifiedName(tp);
      PyErr_Format(PyExc_AttributeError, "'%S' object has no attribute '%s'", tpname, PyString_AsString(encoded_name));
      SWIG_Py_DECREF(tpname);
    }
#else
    PyErr_Format(PyExc_AttributeError, "'%s' object has no attribute '%s'", tp->tp_name, PyString_AsString(encoded_name));
#endif
    SWIG_Py_DECREF(encoded_name);
  } else {
    res = f(descr, obj, value);
  }
  
  done:
  SWIG_Py_DECREF(name);
  return res;
}
#endif


#ifdef __cplusplus
}
#endif



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

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



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

/* -----------------------------------------------------------------------------
 * director_common.swg
 *
 * This file contains support for director classes which is common between
 * languages.
 * ----------------------------------------------------------------------------- */

/*
  Use -DSWIG_DIRECTOR_STATIC if you prefer to avoid the use of the
  'Swig' namespace. This could be useful for multi-modules projects.
*/
#ifdef SWIG_DIRECTOR_STATIC
/* Force anonymous (static) namespace */
#define Swig
#endif
/* -----------------------------------------------------------------------------
 * director_py_mutex.swg
 *
 * contains python mutex for threads
 * ----------------------------------------------------------------------------- */

#if defined(SWIG_PYTHON_THREADS) && !defined(SWIG_THREADS)
#define SWIG_THREADS 1
#endif
#if defined(SWIG_THREADS) && !defined(Py_LIMITED_API)
#include "pythread.h"
#define SWIG_HAVE_MUTEX
namespace Swig {
   class Mutex
   {
       PyThread_type_lock mutex_;
   public:
       Mutex() : mutex_(PyThread_allocate_lock()) {}
       ~Mutex() { PyThread_free_lock(mutex_); }
       void lock() { PyThread_acquire_lock(mutex_, WAIT_LOCK); }
       void unlock() { PyThread_release_lock(mutex_); }
   };
}
#endif
/* -----------------------------------------------------------------------------
 * director_guard.swg
 *
 * Generic Mutex implementation for directors
 *
 * Before including this file, there are two macros to define for choosing
 * an implementation as follows:
 * - SWIG_THREADS:
 *   If defined than mutexes are used.
 *   If not defined then mutexes are not used.
 * - SWIG_HAVE_MUTEX:
 *   If there is a target language defined 'Mutex' class available, the target
 *     language will define this macro to use the class over the options below.
 *     The language 'Mutex' class needs to be Basic Lockable.
 *     It must have public 'void lock()' and 'void unlock()' methods.
 *     See: https://en.cppreference.com/w/cpp/named_req/BasicLockable
 *   If the macro is not defined, one of the following will be used in this order:
 *   - std::mutex if using C++11 or later.
 *   - CRITICAL_SECTION on Windows.
 *   - POSIX pthread mutex.
 * ----------------------------------------------------------------------------- */

#ifdef SWIG_THREADS

#if __cplusplus >= 201103L
/*
 * C++ 11 or above
 * std::mutex        https://en.cppreference.com/w/cpp/thread/mutex
 * std::unique_lock  https://en.cppreference.com/w/cpp/thread/unique_lock
 */
#include <mutex>
#ifdef SWIG_HAVE_MUTEX
/* Use Language defined Mutex class */
#define SWIG_GUARD(_mutex) std::unique_lock<Mutex> _guard(_mutex)
#define SWIG_GUARD_DEFINITION(_cls, _mutex) Mutex _cls::_mutex
#define SWIG_GUARD_DECLARATION(_mutex) static Mutex _mutex
#else
#define SWIG_GUARD(_mutex) std::unique_lock<std::mutex> _guard(_mutex)
#define SWIG_GUARD_DEFINITION(_cls, _mutex) std::mutex _cls::_mutex
#define SWIG_GUARD_DECLARATION(_mutex) static std::mutex _mutex
#endif

#else /* __cplusplus */

#ifdef SWIG_HAVE_MUTEX
/* Use Language defined Mutex class */

#elif defined(_WIN32)
/*
 * Windows Critical Section Objects
 * https://learn.microsoft.com/en-us/windows/win32/Sync/critical-section-objects
 */
#include <windows.h>
#include <synchapi.h>
namespace Swig {
    class Mutex {
        CRITICAL_SECTION mutex_;
    public:
        Mutex() { InitializeCriticalSection(&mutex_); }
        ~Mutex() { DeleteCriticalSection(&mutex_); }
        void lock() { EnterCriticalSection(&mutex_); }
        void unlock() { LeaveCriticalSection(&mutex_); }
    };
}

#else /* _WIN32 */
/*
 * POSIX Thread mutex
 * https://pubs.opengroup.org/onlinepubs/7908799/xsh/pthread.h.html
 */
#include <pthread.h>
namespace Swig {
    class Mutex {
        pthread_mutex_t mutex_;
    public:
        Mutex() { pthread_mutex_init(&mutex_, NULL); }
        ~Mutex() { pthread_mutex_destroy(&mutex_); }
        void lock() { pthread_mutex_lock(&mutex_); }
        void unlock() { pthread_mutex_unlock(&mutex_); }
    };
}

#endif /* _WIN32 */

namespace Swig {
    class Unique_lock {
        Mutex &mutex_;
    public:
        Unique_lock(Mutex &_mutex) : mutex_(_mutex) { mutex_.lock(); }
        ~Unique_lock() { mutex_.unlock(); }
    };
}
#define SWIG_GUARD(_mutex) Unique_lock _guard(_mutex)
#define SWIG_GUARD_DEFINITION(_cls, _mutex) Mutex _cls::_mutex
#define SWIG_GUARD_DECLARATION(_mutex) static Mutex _mutex

#endif /* __cplusplus */

#else /* SWIG_THREADS */

#define SWIG_GUARD(_mutex)
#define SWIG_GUARD_DEFINITION(_cls, _mutex)
#define SWIG_GUARD_DECLARATION(_mutex)

#endif /* SWIG_THREADS */
/* -----------------------------------------------------------------------------
 * director.swg
 *
 * This file contains support for director classes so that Python proxy
 * methods can be called from C++.
 * ----------------------------------------------------------------------------- */

#ifndef SWIG_DIRECTOR_PYTHON_HEADER_
#define SWIG_DIRECTOR_PYTHON_HEADER_

#include <string>
#include <iostream>
#include <exception>
#include <vector>
#include <map>

/*
  Use -DSWIG_PYTHON_DIRECTOR_NO_VTABLE if you don't want to generate a 'virtual
  table', and avoid multiple GetAttr calls to retrieve the python
  methods.
*/

#ifndef SWIG_PYTHON_DIRECTOR_NO_VTABLE
#ifndef SWIG_PYTHON_DIRECTOR_VTABLE
#define SWIG_PYTHON_DIRECTOR_VTABLE
#endif
#endif



/*
  Use -DSWIG_DIRECTOR_NO_UEH if you prefer to avoid the use of the
  Undefined Exception Handler provided by swig.
*/
#ifndef SWIG_DIRECTOR_NO_UEH
#ifndef SWIG_DIRECTOR_UEH
#define SWIG_DIRECTOR_UEH
#endif
#endif


/*
  Use -DSWIG_DIRECTOR_NORTTI if you prefer to avoid the use of the
  native C++ RTTI and dynamic_cast<>. But be aware that directors
  could stop working when using this option.
*/
#ifdef SWIG_DIRECTOR_NORTTI
/*
   When we don't use the native C++ RTTI, we implement a minimal one
   only for Directors.
*/
# ifndef SWIG_DIRECTOR_RTDIR
# define SWIG_DIRECTOR_RTDIR

namespace Swig {
  class Director;
  SWIGINTERN std::map<void *, Director *>& get_rtdir_map() {
    static std::map<void *, Director *> rtdir_map;
    return rtdir_map;
  }

  SWIGINTERNINLINE void set_rtdir(void *vptr, Director *rtdir) {
    get_rtdir_map()[vptr] = rtdir;
  }

  SWIGINTERNINLINE Director *get_rtdir(void *vptr) {
    std::map<void *, Director *>::const_iterator pos = get_rtdir_map().find(vptr);
    Director *rtdir = (pos != get_rtdir_map().end()) ? pos->second : 0;
    return rtdir;
  }
}
# endif /* SWIG_DIRECTOR_RTDIR */

# define SWIG_DIRECTOR_CAST(ARG) Swig::get_rtdir(static_cast<void *>(ARG))
# define SWIG_DIRECTOR_RGTR(ARG1, ARG2) Swig::set_rtdir(static_cast<void *>(ARG1), ARG2)

#else

# define SWIG_DIRECTOR_CAST(ARG) dynamic_cast<Swig::Director *>(ARG)
# define SWIG_DIRECTOR_RGTR(ARG1, ARG2)

#endif /* SWIG_DIRECTOR_NORTTI */

extern "C" {
  struct swig_type_info;
}

namespace Swig {

  /* memory handler */
  struct GCItem {
    virtual ~GCItem() {}

    virtual int get_own() const {
      return 0;
    }
  };

  struct GCItem_var {
    GCItem_var(GCItem *item = 0) : _item(item) {
    }

    GCItem_var& operator=(GCItem *item) {
      GCItem *tmp = _item;
      _item = item;
      delete tmp;
      return *this;
    }

    ~GCItem_var() {
      delete _item;
    }

    GCItem * operator->() const {
      return _item;
    }

  private:
    GCItem *_item;
  };

  struct GCItem_Object : GCItem {
    GCItem_Object(int own) : _own(own) {
    }

    virtual ~GCItem_Object() {
    }

    int get_own() const {
      return _own;
    }

  private:
    int _own;
  };

  template <typename Type>
  struct GCItem_T : GCItem {
    GCItem_T(Type *ptr) : _ptr(ptr) {
    }

    virtual ~GCItem_T() {
      delete _ptr;
    }

  private:
    Type *_ptr;
  };

  template <typename Type>
  struct GCArray_T : GCItem {
    GCArray_T(Type *ptr) : _ptr(ptr) {
    }

    virtual ~GCArray_T() {
      delete[] _ptr;
    }

  private:
    Type *_ptr;
  };

  /* base class for director exceptions */
  class DirectorException : public std::exception {
  protected:
    std::string swig_msg;
  public:
    DirectorException(PyObject *error, const char *hdr ="", const char *msg ="") : swig_msg(hdr) {
      SWIG_PYTHON_THREAD_BEGIN_BLOCK;
      if (msg[0]) {
        swig_msg += " ";
        swig_msg += msg;
      }
      if (!PyErr_Occurred()) {
        PyErr_SetString(error, swig_msg.c_str());
      }
      SWIG_PYTHON_THREAD_END_BLOCK;
    }

    virtual ~DirectorException() SWIG_NOEXCEPT {
    }

    /* Deprecated, use what() instead */
    const char *getMessage() const {
      return what();
    }

    const char *what() const SWIG_NOEXCEPT {
      return swig_msg.c_str();
    }

    static void raise(PyObject *error, const char *msg) {
      throw DirectorException(error, msg);
    }

    static void raise(const char *msg) {
      raise(PyExc_RuntimeError, msg);
    }
  };

  /* type mismatch in the return value from a python method call */
  class DirectorTypeMismatchException : public DirectorException {
  public:
    DirectorTypeMismatchException(PyObject *error, const char *msg="")
      : DirectorException(error, "SWIG director type mismatch", msg) {
    }

    DirectorTypeMismatchException(const char *msg="")
      : DirectorException(PyExc_TypeError, "SWIG director type mismatch", msg) {
    }

    static void raise(PyObject *error, const char *msg) {
      throw DirectorTypeMismatchException(error, msg);
    }

    static void raise(const char *msg) {
      throw DirectorTypeMismatchException(msg);
    }
  };

  /* any python exception that occurs during a director method call */
  class DirectorMethodException : public DirectorException {
  public:
    DirectorMethodException(const char *msg = "")
      : DirectorException(PyExc_RuntimeError, "SWIG director method error.", msg) {
    }

    static void raise(const char *msg) {
      throw DirectorMethodException(msg);
    }
  };

  /* attempt to call a pure virtual method via a director method */
  class DirectorPureVirtualException : public DirectorException {
  public:
    DirectorPureVirtualException(const char *msg = "")
      : DirectorException(PyExc_RuntimeError, "SWIG director pure virtual method called", msg) {
    }

    static void raise(const char *msg) {
      throw DirectorPureVirtualException(msg);
    }
  };



  /* director base class */
  class Director {
  private:
    /* pointer to the wrapped python object */
    PyObject *swig_self;
    /* flag indicating whether the object is owned by python or c++ */
    mutable bool swig_disown_flag;

    /* decrement the reference count of the wrapped python object */
    void swig_decref() const {
      if (swig_disown_flag) {
        SWIG_PYTHON_THREAD_BEGIN_BLOCK;
        SWIG_Py_DECREF(swig_self);
        SWIG_PYTHON_THREAD_END_BLOCK;
      }
    }

  public:
    /* wrap a python object. */
    Director(PyObject *self) : swig_self(self), swig_disown_flag(false) {
    }

    /* discard our reference at destruction */
    virtual ~Director() {
      swig_decref();
    }

    /* return a pointer to the wrapped python object */
    PyObject *swig_get_self() const {
      return swig_self;
    }

    /* acquire ownership of the wrapped python object (the sense of "disown" is from python) */
    void swig_disown() const {
      if (!swig_disown_flag) {
        swig_disown_flag=true;
        swig_incref();
      }
    }

    /* increase the reference count of the wrapped python object */
    void swig_incref() const {
      if (swig_disown_flag) {
        SWIG_Py_INCREF(swig_self);
      }
    }

    /* methods to implement pseudo protected director members */
    virtual bool swig_get_inner(const char * /* swig_protected_method_name */) const {
      return true;
    }

    virtual void swig_set_inner(const char * /* swig_protected_method_name */, bool /* swig_val */) const {
    }

  /* ownership management */
  private:
    typedef std::map<void *, GCItem_var> swig_ownership_map;
    mutable swig_ownership_map swig_owner;
    SWIG_GUARD_DECLARATION(swig_mutex_own);

  public:
    template <typename Type>
    void swig_acquire_ownership_array(Type *vptr) const {
      if (vptr) {
        SWIG_GUARD(swig_mutex_own);
        swig_owner[vptr] = new GCArray_T<Type>(vptr);
      }
    }

    template <typename Type>
    void swig_acquire_ownership(Type *vptr) const {
      if (vptr) {
        SWIG_GUARD(swig_mutex_own);
        swig_owner[vptr] = new GCItem_T<Type>(vptr);
      }
    }

    void swig_acquire_ownership_obj(void *vptr, int own) const {
      if (vptr && own) {
        SWIG_GUARD(swig_mutex_own);
        swig_owner[vptr] = new GCItem_Object(own);
      }
    }

    int swig_release_ownership(void *vptr) const {
      int own = 0;
      if (vptr) {
        SWIG_GUARD(swig_mutex_own);
        swig_ownership_map::iterator iter = swig_owner.find(vptr);
        if (iter != swig_owner.end()) {
          own = iter->second->get_own();
          swig_owner.erase(iter);
        }
      }
      return own;
    }

    template <typename Type>
    static PyObject *swig_pyobj_disown(PyObject *pyobj, PyObject *SWIGUNUSEDPARM(args)) {
      SwigPyObject *sobj = (SwigPyObject *)pyobj;
      sobj->own = 0;
      Director *d = SWIG_DIRECTOR_CAST(reinterpret_cast<Type *>(sobj->ptr));
      if (d)
        d->swig_disown();
      return PyWeakref_NewProxy(pyobj, NULL);
    }
  };

  SWIG_GUARD_DEFINITION(Director, swig_mutex_own);
}

#endif

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

#define SWIGTYPE_p_MarkupCallback swig_types[0]
#define SWIGTYPE_p_MyMarkup swig_types[1]
#define SWIGTYPE_p_OSISData swig_types[2]
#define SWIGTYPE_p_ParameterMap swig_types[3]
#define SWIGTYPE_p_PyOSISHTMLHREF swig_types[4]
#define SWIGTYPE_p_PyStringMgr swig_types[5]
#define SWIGTYPE_p_PyThMLHTMLHREF swig_types[6]
#define SWIGTYPE_p_RenderCallback swig_types[7]
#define SWIGTYPE_p_ReturnSuccess swig_types[8]
#define SWIGTYPE_p_SWSearcher swig_types[9]
#define SWIGTYPE_p_SW_u16 swig_types[10]
#define SWIGTYPE_p_SW_u32 swig_types[11]
#define SWIGTYPE_p_ThMLData swig_types[12]
#define SWIGTYPE_p_allocator_type swig_types[13]
#define SWIGTYPE_p_char swig_types[14]
#define SWIGTYPE_p_difference_type swig_types[15]
#define SWIGTYPE_p_first_type swig_types[16]
#define SWIGTYPE_p_int swig_types[17]
#define SWIGTYPE_p_key_type swig_types[18]
#define SWIGTYPE_p_long swig_types[19]
#define SWIGTYPE_p_mapped_type swig_types[20]
#define SWIGTYPE_p_p_PyObject swig_types[21]
#define SWIGTYPE_p_p_char swig_types[22]
#define SWIGTYPE_p_second_type swig_types[23]
#define SWIGTYPE_p_size_type swig_types[24]
#define SWIGTYPE_p_std__allocatorT_std__pairT_sword__SWBuf_const_std__mapT_sword__SWBuf_AttributeValueMap_t_t_t swig_types[25]
#define SWIGTYPE_p_std__allocatorT_std__pairT_sword__SWBuf_const_std__mapT_sword__SWBuf_sword__SWBuf_t_t_t swig_types[26]
#define SWIGTYPE_p_std__allocatorT_std__pairT_sword__SWBuf_const_std__multimapT_sword__SWBuf_sword__SWBuf_std__lessT_sword__SWBuf_t_t_t_t swig_types[27]
#define SWIGTYPE_p_std__allocatorT_std__pairT_sword__SWBuf_const_sword__InstallSource_p_t_t swig_types[28]
#define SWIGTYPE_p_std__allocatorT_std__pairT_sword__SWBuf_const_sword__SWBuf_t_t swig_types[29]
#define SWIGTYPE_p_std__allocatorT_std__pairT_sword__SWBuf_const_sword__SWModule_p_t_t swig_types[30]
#define SWIGTYPE_p_std__allocatorT_sword__DirEntry_t swig_types[31]
#define SWIGTYPE_p_std__allocatorT_sword__SWBuf_t swig_types[32]
#define SWIGTYPE_p_std__invalid_argument swig_types[33]
#define SWIGTYPE_p_std__lessT_sword__SWBuf_t swig_types[34]
#define SWIGTYPE_p_std__listT_sword__SWBuf_t swig_types[35]
#define SWIGTYPE_p_std__listT_sword__SWFilter_p_std__allocatorT_sword__SWFilter_p_t_t swig_types[36]
#define SWIGTYPE_p_std__listT_sword__SWOptionFilter_p_std__allocatorT_sword__SWOptionFilter_p_t_t swig_types[37]
#define SWIGTYPE_p_std__mapT_sword__SWBuf_AttributeListMap_t swig_types[38]
#define SWIGTYPE_p_std__mapT_sword__SWBuf_AttributeValueMap_t swig_types[39]
#define SWIGTYPE_p_std__mapT_sword__SWBuf_std__multimapT_sword__SWBuf_sword__SWBuf_std__lessT_sword__SWBuf_t_t_t swig_types[40]
#define SWIGTYPE_p_std__mapT_sword__SWBuf_sword__InstallSource_p_t swig_types[41]
#define SWIGTYPE_p_std__mapT_sword__SWBuf_sword__SWBuf_t swig_types[42]
#define SWIGTYPE_p_std__mapT_sword__SWBuf_sword__SWFilter_p_std__lessT_sword__SWBuf_t_std__allocatorT_std__pairT_sword__SWBuf_const_sword__SWFilter_p_t_t_t swig_types[43]
#define SWIGTYPE_p_std__mapT_sword__SWBuf_sword__SWLocale_p_std__lessT_sword__SWBuf_t_std__allocatorT_std__pairT_sword__SWBuf_const_sword__SWLocale_p_t_t_t swig_types[44]
#define SWIGTYPE_p_std__mapT_sword__SWBuf_sword__SWModule_p_t swig_types[45]
#define SWIGTYPE_p_std__mapT_sword__SWBuf_sword__SWOptionFilter_p_std__lessT_sword__SWBuf_t_std__allocatorT_std__pairT_sword__SWBuf_const_sword__SWOptionFilter_p_t_t_t swig_types[46]
#define SWIGTYPE_p_std__mapT_sword__SWBuf_sword__multimapwithdefaultT_sword__SWBuf_sword__SWBuf_std__lessT_sword__SWBuf_t_t_std__lessT_sword__SWBuf_t_std__allocatorT_std__pairT_sword__SWBuf_const_sword__multimapwithdefaultT_sword__SWBuf_sword__SWBuf_std__lessT_sword__SWBuf_t_t_t_t_t swig_types[47]
#define SWIGTYPE_p_std__multimapT_sword__SWBuf_sword__SWBuf_std__lessT_sword__SWBuf_t_t swig_types[48]
#define SWIGTYPE_p_std__vectorT_sword__DirEntry_t swig_types[49]
#define SWIGTYPE_p_std__vectorT_sword__SWBuf_t swig_types[50]
#define SWIGTYPE_p_swig__SwigPyIterator swig_types[51]
#define SWIGTYPE_p_sword__BasicFilterUserData swig_types[52]
#define SWIGTYPE_p_sword__DirEntry swig_types[53]
#define SWIGTYPE_p_sword__EncodingFilterMgr swig_types[54]
#define SWIGTYPE_p_sword__FileDesc swig_types[55]
#define SWIGTYPE_p_sword__FileMgr swig_types[56]
#define SWIGTYPE_p_sword__GBFHTMLHREF swig_types[57]
#define SWIGTYPE_p_sword__InstallMgr swig_types[58]
#define SWIGTYPE_p_sword__InstallSource swig_types[59]
#define SWIGTYPE_p_sword__LZSSCompress swig_types[60]
#define SWIGTYPE_p_sword__ListKey swig_types[61]
#define SWIGTYPE_p_sword__LocaleMgr swig_types[62]
#define SWIGTYPE_p_sword__MarkupFilterMgr swig_types[63]
#define SWIGTYPE_p_sword__OSISHTMLHREF swig_types[64]
#define SWIGTYPE_p_sword__RawCom swig_types[65]
#define SWIGTYPE_p_sword__RawGenBook swig_types[66]
#define SWIGTYPE_p_sword__RawLD swig_types[67]
#define SWIGTYPE_p_sword__RawLD4 swig_types[68]
#define SWIGTYPE_p_sword__RawStr swig_types[69]
#define SWIGTYPE_p_sword__RawStr4 swig_types[70]
#define SWIGTYPE_p_sword__RawText swig_types[71]
#define SWIGTYPE_p_sword__RawVerse swig_types[72]
#define SWIGTYPE_p_sword__RemoteTransport swig_types[73]
#define SWIGTYPE_p_sword__SWBasicFilter swig_types[74]
#define SWIGTYPE_p_sword__SWBuf swig_types[75]
#define SWIGTYPE_p_sword__SWClass swig_types[76]
#define SWIGTYPE_p_sword__SWCom swig_types[77]
#define SWIGTYPE_p_sword__SWCompress swig_types[78]
#define SWIGTYPE_p_sword__SWConfig swig_types[79]
#define SWIGTYPE_p_sword__SWDisplay swig_types[80]
#define SWIGTYPE_p_sword__SWFilter swig_types[81]
#define SWIGTYPE_p_sword__SWFilterMgr swig_types[82]
#define SWIGTYPE_p_sword__SWGenBook swig_types[83]
#define SWIGTYPE_p_sword__SWKey swig_types[84]
#define SWIGTYPE_p_sword__SWLD swig_types[85]
#define SWIGTYPE_p_sword__SWLocale swig_types[86]
#define SWIGTYPE_p_sword__SWLog swig_types[87]
#define SWIGTYPE_p_sword__SWMgr swig_types[88]
#define SWIGTYPE_p_sword__SWModule swig_types[89]
#define SWIGTYPE_p_sword__SWObject swig_types[90]
#define SWIGTYPE_p_sword__SWOptionFilter swig_types[91]
#define SWIGTYPE_p_sword__SWSearchable swig_types[92]
#define SWIGTYPE_p_sword__SWText swig_types[93]
#define SWIGTYPE_p_sword__SWVersion swig_types[94]
#define SWIGTYPE_p_sword__SW_POSITION swig_types[95]
#define SWIGTYPE_p_sword__StatusReporter swig_types[96]
#define SWIGTYPE_p_sword__StringMgr swig_types[97]
#define SWIGTYPE_p_sword__ThMLHTMLHREF swig_types[98]
#define SWIGTYPE_p_sword__TreeKey swig_types[99]
#define SWIGTYPE_p_sword__TreeKeyIdx swig_types[100]
#define SWIGTYPE_p_sword__TreeKey__PositionChangeListener swig_types[101]
#define SWIGTYPE_p_sword__URL swig_types[102]
#define SWIGTYPE_p_sword__UTF8HTML swig_types[103]
#define SWIGTYPE_p_sword__VerseKey swig_types[104]
#define SWIGTYPE_p_sword__VerseTreeKey swig_types[105]
#define SWIGTYPE_p_sword__VersificationMgr swig_types[106]
#define SWIGTYPE_p_sword__VersificationMgr__System swig_types[107]
#define SWIGTYPE_p_sword__XMLTag swig_types[108]
#define SWIGTYPE_p_sword__ZipCompress swig_types[109]
#define SWIGTYPE_p_sword__abbrev swig_types[110]
#define SWIGTYPE_p_sword__multimapwithdefaultT_sword__SWBuf_sword__SWBuf_std__lessT_sword__SWBuf_t_t swig_types[111]
#define SWIGTYPE_p_sword__multimapwithdefaultT_sword__SWBuf_sword__SWBuf_std__lessT_sword__SWBuf_t_t__iterator swig_types[112]
#define SWIGTYPE_p_sword__sbook swig_types[113]
#define SWIGTYPE_p_sword__zCom swig_types[114]
#define SWIGTYPE_p_sword__zLD swig_types[115]
#define SWIGTYPE_p_sword__zStr swig_types[116]
#define SWIGTYPE_p_sword__zText swig_types[117]
#define SWIGTYPE_p_sword__zVerse swig_types[118]
#define SWIGTYPE_p_unsigned_char swig_types[119]
#define SWIGTYPE_p_unsigned_long swig_types[120]
#define SWIGTYPE_p_unsigned_short swig_types[121]
#define SWIGTYPE_p_value_type swig_types[122]
static swig_type_info *swig_types[124];
static swig_module_info swig_module = {swig_types, 123, 0, 0, 0, 0};
#define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
#define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)

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

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

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

#else
#  define SWIG_init    init_Sword

#endif

#ifdef __cplusplus
#include <utility>
/* SwigValueWrapper is described in swig.swg */
template<typename T> class SwigValueWrapper {
  struct SwigSmartPointer {
    T *ptr;
    SwigSmartPointer(T *p) : ptr(p) { }
    ~SwigSmartPointer() { delete ptr; }
    SwigSmartPointer& operator=(SwigSmartPointer& rhs) { T* oldptr = ptr; ptr = 0; delete oldptr; ptr = rhs.ptr; rhs.ptr = 0; return *this; }
    void reset(T *p) { T* oldptr = ptr; ptr = 0; delete oldptr; ptr = p; }
  } pointer;
  SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
  SwigValueWrapper(const SwigValueWrapper<T>& rhs);
public:
  SwigValueWrapper() : pointer(0) { }
  SwigValueWrapper& operator=(const T& t) { SwigSmartPointer tmp(new T(t)); pointer = tmp; return *this; }
#if __cplusplus >=201103L
  SwigValueWrapper& operator=(T&& t) { SwigSmartPointer tmp(new T(std::move(t))); pointer = tmp; return *this; }
  operator T&&() const { return std::move(*pointer.ptr); }
#else
  operator T&() const { return *pointer.ptr; }
#endif
  T *operator&() const { return pointer.ptr; }
  static void reset(SwigValueWrapper& t, T *p) { t.pointer.reset(p); }
};

/*
 * SwigValueInit() is a generic initialisation solution as the following approach:
 * 
 *       T c_result = T();
 * 
 * doesn't compile for all types for example:
 * 
 *       unsigned int c_result = unsigned int();
 */
template <typename T> T SwigValueInit() {
  return T();
}

#if __cplusplus >=201103L
# define SWIG_STD_MOVE(OBJ) std::move(OBJ)
#else
# define SWIG_STD_MOVE(OBJ) OBJ
#endif

#endif


#define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a)) 
#define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a)) 


#include <stdexcept>


namespace swig {
  class SwigPtr_PyObject {
  protected:
    PyObject *_obj;

  public:
    SwigPtr_PyObject() :_obj(0)
    {
    }

    SwigPtr_PyObject(const SwigPtr_PyObject& item) : _obj(item._obj)
    {
      SWIG_PYTHON_THREAD_BEGIN_BLOCK;
      SWIG_Py_XINCREF(_obj);
      SWIG_PYTHON_THREAD_END_BLOCK;
    }
    
    SwigPtr_PyObject(PyObject *obj, bool initial_ref = true) :_obj(obj)
    {
      if (initial_ref) {
        SWIG_PYTHON_THREAD_BEGIN_BLOCK;
        SWIG_Py_XINCREF(_obj);
        SWIG_PYTHON_THREAD_END_BLOCK;
      }
    }
    
    SwigPtr_PyObject & operator=(const SwigPtr_PyObject& item) 
    {
      SWIG_PYTHON_THREAD_BEGIN_BLOCK;
      SWIG_Py_XINCREF(item._obj);
      SWIG_Py_XDECREF(_obj);
      _obj = item._obj;
      SWIG_PYTHON_THREAD_END_BLOCK;
      return *this;      
    }
    
    ~SwigPtr_PyObject() 
    {
      SWIG_PYTHON_THREAD_BEGIN_BLOCK;
      SWIG_Py_XDECREF(_obj);
      SWIG_PYTHON_THREAD_END_BLOCK;
    }
    
    operator PyObject *() const
    {
      return _obj;
    }

    PyObject *operator->() const
    {
      return _obj;
    }
  };
}


namespace swig {
  struct SwigVar_PyObject : SwigPtr_PyObject {
    SwigVar_PyObject(PyObject* obj = 0) : SwigPtr_PyObject(obj, false) { }
    
    SwigVar_PyObject & operator = (PyObject* obj)
    {
      SWIG_Py_XDECREF(_obj);
      _obj = obj;
      return *this;      
    }
  };
}


#include "defs.h"


#include "swbuf.h"


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


SWIGINTERN swig_type_info*
SWIG_pchar_descriptor(void)
{
  static swig_type_info* info = 0;
  if (!info) {
    info = SWIG_TypeQuery("_p_char");
  }
  return info;
}


/* Return string from Python obj. NOTE: obj must remain in scope in order
   to use the returned cptr (but only when alloc is set to SWIG_OLDOBJ) */
SWIGINTERN int
SWIG_AsCharPtrAndSize(PyObject *obj, char **cptr, size_t *psize, int *alloc)
{
#if PY_VERSION_HEX >= 0x03000000
#if defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
  if (PyBytes_Check(obj))
#else
  if (PyUnicode_Check(obj))
#endif
#else  
  if (PyString_Check(obj))
#endif
  {
    char *cstr; Py_ssize_t len;
    PyObject *bytes = NULL;
    int ret = SWIG_OK;
    if (alloc)
      *alloc = SWIG_OLDOBJ;
#if PY_VERSION_HEX >= 0x03000000 && defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
    if (PyBytes_AsStringAndSize(obj, &cstr, &len) == -1)
      return SWIG_TypeError;
#else
    cstr = (char *)SWIG_PyUnicode_AsUTF8AndSize(obj, &len, &bytes);
    if (!cstr)
      return SWIG_TypeError;
    /* The returned string is only duplicated if the char * returned is not owned and memory managed by obj */
    if (bytes && cptr) {
      if (alloc) {
        cstr = reinterpret_cast< char* >(memcpy(new char[len + 1], cstr, sizeof(char)*(len + 1)));
        *alloc = SWIG_NEWOBJ;
      } else {
        /* alloc must be set in order to clean up allocated memory */
        return SWIG_RuntimeError;
      }
    }
#endif
    if (cptr) *cptr = cstr;
    if (psize) *psize = len + 1;
    SWIG_Py_XDECREF(bytes);
    return ret;
  } else {
#if defined(SWIG_PYTHON_2_UNICODE)
#if defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
#error "Cannot use both SWIG_PYTHON_2_UNICODE and SWIG_PYTHON_STRICT_BYTE_CHAR at once"
#endif
#if PY_VERSION_HEX < 0x03000000
    if (PyUnicode_Check(obj)) {
      char *cstr; Py_ssize_t len;
      if (!alloc && cptr) {
        return SWIG_RuntimeError;
      }
      obj = PyUnicode_AsUTF8String(obj);
      if (!obj)
        return SWIG_TypeError;
      if (PyString_AsStringAndSize(obj, &cstr, &len) != -1) {
        if (cptr) {
          if (alloc) *alloc = SWIG_NEWOBJ;
          *cptr = reinterpret_cast< char* >(memcpy(new char[len + 1], cstr, sizeof(char)*(len + 1)));
        }
        if (psize) *psize = len + 1;

        SWIG_Py_XDECREF(obj);
        return SWIG_OK;
      } else {
        SWIG_Py_XDECREF(obj);
      }
    }
#endif
#endif

    swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
    if (pchar_descriptor) {
      void* vptr = 0;
      if (SWIG_ConvertPtr(obj, &vptr, pchar_descriptor, 0) == SWIG_OK) {
	if (cptr) *cptr = (char *) vptr;
	if (psize) *psize = vptr ? (strlen((char *)vptr) + 1) : 0;
	if (alloc) *alloc = SWIG_OLDOBJ;
	return SWIG_OK;
      }
    }
  }
  return SWIG_TypeError;
}


SWIGINTERNINLINE PyObject *
SWIG_FromCharPtrAndSize(const char* carray, size_t size)
{
  if (carray) {
    if (size > (size_t)PY_SSIZE_T_MAX) {
      swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
      return pchar_descriptor ? 
	SWIG_InternalNewPointerObj(const_cast< char * >(carray), pchar_descriptor, 0) : SWIG_Py_Void();
    } else {
#if PY_VERSION_HEX >= 0x03000000
#if defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
      return PyBytes_FromStringAndSize(carray, static_cast< Py_ssize_t >(size));
#else
      return PyUnicode_DecodeUTF8(carray, static_cast< Py_ssize_t >(size), "surrogateescape");
#endif
#else
      return PyString_FromStringAndSize(carray, static_cast< Py_ssize_t >(size));
#endif
    }
  } else {
    return SWIG_Py_Void();
  }
}


SWIGINTERNINLINE PyObject * 
SWIG_FromCharPtr(const char *cptr)
{ 
  return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
}





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


#include <errno.h>


#include <float.h>


#include <math.h>


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


SWIGINTERN int
SWIG_AsVal_unsigned_SS_long (PyObject *obj, unsigned long *val) 
{
#if PY_VERSION_HEX < 0x03000000
  if (PyInt_Check(obj)) {
    long v = PyInt_AsLong(obj);
    if (v >= 0) {
      if (val) *val = v;
      return SWIG_OK;
    } else {
      return SWIG_OverflowError;
    }
  } else
#endif
  if (PyLong_Check(obj)) {
    unsigned long v = PyLong_AsUnsignedLong(obj);
    if (!PyErr_Occurred()) {
      if (val) *val = v;
      return SWIG_OK;
    } else {
      PyErr_Clear();
      return SWIG_OverflowError;
    }
  }
#ifdef SWIG_PYTHON_CAST_MODE
  {
    int dispatch = 0;
    unsigned long v = PyLong_AsUnsignedLong(obj);
    if (!PyErr_Occurred()) {
      if (val) *val = v;
      return SWIG_AddCast(SWIG_OK);
    } else {
      PyErr_Clear();
    }
    if (!dispatch) {
      double d;
      int res = SWIG_AddCast(SWIG_AsVal_double (obj,&d));
      // Largest double not larger than ULONG_MAX (not portably calculated easily)
      // Note that double(ULONG_MAX) is stored in a double rounded up by one (for 64-bit unsigned long)
      // 0xfffffffffffff800ULL == (uint64_t)std::nextafter(double(__uint128_t(ULONG_MAX)+1), double(0))
      const double ulong_max = sizeof(unsigned long) == 8 ? 0xfffffffffffff800ULL : ULONG_MAX;
      if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, 0, ulong_max)) {
	if (val) *val = (unsigned long)(d);
	return res;
      }
    }
  }
#endif
  return SWIG_TypeError;
}


SWIGINTERN int
SWIG_AsCharArray(PyObject * obj, char *val, size_t size)
{ 
  char* cptr = 0; size_t csize = 0; int alloc = SWIG_OLDOBJ;
  int res = SWIG_AsCharPtrAndSize(obj, &cptr, &csize, &alloc);
  if (SWIG_IsOK(res)) {
    /* special case of single char conversion when we don't need space for NUL */
    if (size == 1 && csize == 2 && cptr && !cptr[1]) --csize;
    if (csize <= size) {
      if (val) {
	if (csize) memcpy(val, cptr, csize*sizeof(char));
	if (csize < size) memset(val + csize, 0, (size - csize)*sizeof(char));
      }
      if (alloc == SWIG_NEWOBJ) {
	delete[] cptr;
	res = SWIG_DelNewMask(res);
      }      
      return res;
    }
    if (alloc == SWIG_NEWOBJ) delete[] cptr;
  }
  return SWIG_TypeError;
}


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


SWIGINTERN int
SWIG_AsVal_long (PyObject *obj, long* val)
{
#if PY_VERSION_HEX < 0x03000000
  if (PyInt_Check(obj)) {
    if (val) *val = PyInt_AsLong(obj);
    return SWIG_OK;
  } else
#endif
  if (PyLong_Check(obj)) {
    long v = PyLong_AsLong(obj);
    if (!PyErr_Occurred()) {
      if (val) *val = v;
      return SWIG_OK;
    } else {
      PyErr_Clear();
      return SWIG_OverflowError;
    }
  }
#ifdef SWIG_PYTHON_CAST_MODE
  {
    int dispatch = 0;
    long v = PyInt_AsLong(obj);
    if (!PyErr_Occurred()) {
      if (val) *val = v;
      return SWIG_AddCast(SWIG_OK);
    } else {
      PyErr_Clear();
    }
    if (!dispatch) {
      double d;
      int res = SWIG_AddCast(SWIG_AsVal_double (obj,&d));
      // Largest double not larger than LONG_MAX (not portably calculated easily)
      // Note that double(LONG_MAX) is stored in a double rounded up by one (for 64-bit long)
      // 0x7ffffffffffffc00LL == (int64_t)std::nextafter(double(__uint128_t(LONG_MAX)+1), double(0))
      const double long_max = sizeof(long) == 8 ? 0x7ffffffffffffc00LL : LONG_MAX;
      // No equivalent needed for 64-bit double(LONG_MIN) is exactly LONG_MIN
      if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, LONG_MIN, long_max)) {
	if (val) *val = (long)(d);
	return res;
      }
    }
  }
#endif
  return SWIG_TypeError;
}


SWIGINTERN int
SWIG_AsVal_char (PyObject * obj, char *val)
{    
  int res = SWIG_AsCharArray(obj, val, 1);
  if (!SWIG_IsOK(res)) {
    long v;
    res = SWIG_AddCast(SWIG_AsVal_long (obj, &v));
    if (SWIG_IsOK(res)) {
      if ((CHAR_MIN <= v) && (v <= CHAR_MAX)) {
	if (val) *val = static_cast< char >(v);
      } else {
	res = SWIG_OverflowError;
      }
    }
  }
  return res;
}


SWIGINTERNINLINE PyObject *
SWIG_From_char  (char c) 
{ 
  return SWIG_FromCharPtrAndSize(&c,1);
}


  #define SWIG_From_long   PyInt_FromLong 


SWIGINTERNINLINE PyObject* 
SWIG_From_unsigned_SS_long  (unsigned long value)
{
  return (value > LONG_MAX) ?
    PyLong_FromUnsignedLong(value) : PyInt_FromLong(static_cast< long >(value));
}


SWIGINTERN int
SWIG_AsVal_unsigned_SS_char (PyObject * obj, unsigned char *val)
{
  unsigned long v;
  int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
  if (SWIG_IsOK(res)) {
    if ((v > UCHAR_MAX)) {
      return SWIG_OverflowError;
    } else {
      if (val) *val = static_cast< unsigned char >(v);
    }
  }  
  return res;
}


SWIGINTERN int
SWIG_AsVal_bool (PyObject *obj, bool *val)
{
  int r;
  if (!PyBool_Check(obj))
    return SWIG_ERROR;
  r = PyObject_IsTrue(obj);
  if (r == -1)
    return SWIG_ERROR;
  if (val) *val = r ? true : false;
  return SWIG_OK;
}


SWIGINTERNINLINE PyObject*
  SWIG_From_bool  (bool value)
{
  return PyBool_FromLong(value ? 1 : 0);
}


SWIGINTERN int
SWIG_AsVal_unsigned_SS_int (PyObject * obj, unsigned int *val)
{
  unsigned long v;
  int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
  if (SWIG_IsOK(res)) {
    if ((v > UINT_MAX)) {
      return SWIG_OverflowError;
    } else {
      if (val) *val = static_cast< unsigned int >(v);
    }
  }  
  return res;
}

SWIGINTERN char sword_SWBuf_charAt2(sword::SWBuf *self,unsigned int pos){
                return self->charAt((unsigned long)pos);
        }

#include "multimapwdef.h"


#include <typeinfo>
#include <stdexcept>


#if defined(__GNUC__)
#  if __GNUC__ == 2 && __GNUC_MINOR <= 96
#     define SWIG_STD_NOMODERN_STL
#  endif
#endif


#include <string>


#include <stddef.h>


#include <iostream>

#if PY_VERSION_HEX >= 0x03020000
# define SWIGPY_SLICEOBJECT PyObject
#else
# define SWIGPY_SLICEOBJECT PySliceObject
#endif


namespace swig {
  struct SwigPyIterator {
  private:
    SwigPtr_PyObject _seq;

  protected:
    SwigPyIterator(PyObject *seq) : _seq(seq)
    {
    }

    void raise_stop_iteration() const
    {
      SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
    }

  public:
    virtual ~SwigPyIterator() {}

    // Access iterator method, required by Python
    virtual PyObject *value() const = 0;

    // Forward iterator method, required by Python
    virtual SwigPyIterator *incr(size_t n = 1) = 0;
    
    // Backward iterator method, very common in C++, but not required in Python
    // This default probably ought to instead raise some sort of unsupported exception
    virtual SwigPyIterator *decr(size_t /*n*/ = 1)
    {
      raise_stop_iteration();
      return NULL;
    }

    // Random access iterator methods, but not required in Python
    virtual ptrdiff_t distance(const SwigPyIterator &/*x*/) const
    {
      throw std::invalid_argument("operation not supported");
    }

    virtual bool equal (const SwigPyIterator &/*x*/) const
    {
      throw std::invalid_argument("operation not supported");
    }
    
    // C++ common/needed methods
    virtual SwigPyIterator *copy() const = 0;

    PyObject *next()     
    {
      SWIG_PYTHON_THREAD_BEGIN_BLOCK; // disable threads       
      PyObject *obj = value();
      if (obj)
        if (!incr())
          obj = NULL;
      SWIG_PYTHON_THREAD_END_BLOCK; // re-enable threads
      return obj;     
    }

    /* Make an alias for Python 3.x */
    PyObject *__next__()
    {
      return next();
    }

    PyObject *previous()
    {
      SWIG_PYTHON_THREAD_BEGIN_BLOCK; // disable threads       
      if (!decr())
        return NULL;
      PyObject *obj = value();
      SWIG_PYTHON_THREAD_END_BLOCK; // re-enable threads       
      return obj;
    }

    SwigPyIterator *advance(ptrdiff_t n)
    {
      return  (n > 0) ?  incr(n) : decr(-n);
    }
      
    bool operator == (const SwigPyIterator& x)  const
    {
      return equal(x);
    }
      
    bool operator != (const SwigPyIterator& x) const
    {
      return ! operator==(x);
    }
      
    SwigPyIterator& operator += (ptrdiff_t n)
    {
      SwigPyIterator *ret = advance(n);
      return ret ? *ret : *this;
    }

    SwigPyIterator& operator -= (ptrdiff_t n)
    {
      SwigPyIterator *ret = advance(-n);
      return ret ? *ret : *this;
    }
      
    SwigPyIterator* operator + (ptrdiff_t n) const
    {
      return copy()->advance(n);
    }

    SwigPyIterator* operator - (ptrdiff_t n) const
    {
      return copy()->advance(-n);
    }
      
    ptrdiff_t operator - (const SwigPyIterator& x) const
    {
      return x.distance(*this);
    }
      
    static swig_type_info* descriptor() {
      static swig_type_info* desc = SWIG_TypeQuery("swig::SwigPyIterator *");
      return desc;
    }    
  };

#if defined(SWIGPYTHON_BUILTIN)
  inline PyObject* make_output_iterator_builtin (PyObject *pyself)
  {
    SWIG_Py_INCREF(pyself);
    return pyself;
  }
#endif
}


#if defined(LLONG_MAX) && !defined(SWIG_LONG_LONG_AVAILABLE)
#  define SWIG_LONG_LONG_AVAILABLE
#endif


#ifdef SWIG_LONG_LONG_AVAILABLE
SWIGINTERN int
SWIG_AsVal_unsigned_SS_long_SS_long (PyObject *obj, unsigned long long *val)
{
  int res = SWIG_TypeError;
  if (PyLong_Check(obj)) {
    unsigned long long v = PyLong_AsUnsignedLongLong(obj);
    if (!PyErr_Occurred()) {
      if (val) *val = v;
      return SWIG_OK;
    } else {
      PyErr_Clear();
      res = SWIG_OverflowError;
    }
  } else {
    unsigned long v;
    res = SWIG_AsVal_unsigned_SS_long (obj,&v);
    if (SWIG_IsOK(res)) {
      if (val) *val = v;
      return res;
    }
  }
#ifdef SWIG_PYTHON_CAST_MODE
  {
    const double mant_max = 1LL << DBL_MANT_DIG;
    double d;
    res = SWIG_AsVal_double (obj,&d);
    if (SWIG_IsOK(res) && !SWIG_CanCastAsInteger(&d, 0, mant_max))
      return SWIG_OverflowError;
    if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, 0, mant_max)) {
      if (val) *val = (unsigned long long)(d);
      return SWIG_AddCast(res);
    }
    res = SWIG_TypeError;
  }
#endif
  return res;
}
#endif


SWIGINTERNINLINE int
SWIG_AsVal_size_t (PyObject * obj, size_t *val)
{
  int res = SWIG_TypeError;
#ifdef SWIG_LONG_LONG_AVAILABLE
  if (sizeof(size_t) <= sizeof(unsigned long)) {
#endif
    unsigned long v;
    res = SWIG_AsVal_unsigned_SS_long (obj, val ? &v : 0);
    if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v);
#ifdef SWIG_LONG_LONG_AVAILABLE
  } else if (sizeof(size_t) <= sizeof(unsigned long long)) {
    unsigned long long v;
    res = SWIG_AsVal_unsigned_SS_long_SS_long (obj, val ? &v : 0);
    if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v);
  }
#endif
  return res;
}


#ifdef SWIG_LONG_LONG_AVAILABLE
SWIGINTERNINLINE PyObject* 
SWIG_From_long_SS_long  (long long value)
{
  return ((value < LONG_MIN) || (value > LONG_MAX)) ?
    PyLong_FromLongLong(value) : PyInt_FromLong(static_cast< long >(value));
}
#endif


SWIGINTERNINLINE PyObject *
SWIG_From_ptrdiff_t  (ptrdiff_t value)
{    
#ifdef SWIG_LONG_LONG_AVAILABLE
  if (sizeof(ptrdiff_t) <= sizeof(long)) {
#endif
    return SWIG_From_long  (static_cast< long >(value));
#ifdef SWIG_LONG_LONG_AVAILABLE
  } else {
    /* assume sizeof(ptrdiff_t) <= sizeof(long long) */
    return SWIG_From_long_SS_long  (static_cast< long long >(value));
  }
#endif
}


#ifdef SWIG_LONG_LONG_AVAILABLE
SWIGINTERN int
SWIG_AsVal_long_SS_long (PyObject *obj, long long *val)
{
  int res = SWIG_TypeError;
  if (PyLong_Check(obj)) {
    long long v = PyLong_AsLongLong(obj);
    if (!PyErr_Occurred()) {
      if (val) *val = v;
      return SWIG_OK;
    } else {
      PyErr_Clear();
      res = SWIG_OverflowError;
    }
  } else {
    long v;
    res = SWIG_AsVal_long (obj,&v);
    if (SWIG_IsOK(res)) {
      if (val) *val = v;
      return res;
    }
  }
#ifdef SWIG_PYTHON_CAST_MODE
  {
    const double mant_max = 1LL << DBL_MANT_DIG;
    const double mant_min = -mant_max;
    double d;
    res = SWIG_AsVal_double (obj,&d);
    if (SWIG_IsOK(res) && !SWIG_CanCastAsInteger(&d, mant_min, mant_max))
      return SWIG_OverflowError;
    if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, mant_min, mant_max)) {
      if (val) *val = (long long)(d);
      return SWIG_AddCast(res);
    }
    res = SWIG_TypeError;
  }
#endif
  return res;
}
#endif


SWIGINTERNINLINE int
SWIG_AsVal_ptrdiff_t (PyObject * obj, ptrdiff_t *val)
{
  int res = SWIG_TypeError;
#ifdef SWIG_LONG_LONG_AVAILABLE
  if (sizeof(ptrdiff_t) <= sizeof(long)) {
#endif
    long v;
    res = SWIG_AsVal_long (obj, val ? &v : 0);
    if (SWIG_IsOK(res) && val) *val = static_cast< ptrdiff_t >(v);
#ifdef SWIG_LONG_LONG_AVAILABLE
  } else if (sizeof(ptrdiff_t) <= sizeof(long long)) {
    long long v;
    res = SWIG_AsVal_long_SS_long (obj, val ? &v : 0);
    if (SWIG_IsOK(res) && val) *val = static_cast< ptrdiff_t >(v);
  }
#endif
  return res;
}


#include <algorithm>


#include <vector>


#include <utility>


#include <map>


#include <algorithm>


#include <list>


#include "swmodule.h"
#include "filemgr.h"
#include "swconfig.h"


typedef std::map< sword::SWBuf, sword::SWBuf > AttributeValueMap;
typedef std::map< sword::SWBuf, AttributeValueMap> AttributeListMap;
typedef std::map< sword::SWBuf, AttributeListMap> AttributeTypeListMap; 
typedef std::multimap < sword::SWBuf, sword::SWBuf, std::less < sword::SWBuf > > PyConfigEntMap;
typedef std::map < sword::SWBuf, PyConfigEntMap > PySectionMap;


namespace swig {
  template <class Type>
  struct noconst_traits {
    typedef Type noconst_type;
  };

  template <class Type>
  struct noconst_traits<const Type> {
    typedef Type noconst_type;
  };

  /*
    type categories
  */
  struct pointer_category { };
  struct value_category { };

  /*
    General traits that provides type_name and type_info
  */
  template <class Type> struct traits { };

  template <class Type>
  inline const char* type_name() {
    return traits<typename noconst_traits<Type >::noconst_type >::type_name();
  }

  template <class Type> struct traits_info {
    static swig_type_info *type_query(std::string name) {
      name += " *";
      return SWIG_TypeQuery(name.c_str());
    }
    static swig_type_info *type_info() {
      static swig_type_info *info = type_query(type_name<Type>());
      return info;
    }
  };

  /*
    Partial specialization for pointers (traits_info)
  */
  template <class Type> struct traits_info<Type *> {
    static swig_type_info *type_query(std::string name) {
      name += " *";
      return SWIG_TypeQuery(name.c_str());
    }
    static swig_type_info *type_info() {
      static swig_type_info *info = type_query(type_name<Type>());
      return info;
    }
  };

  template <class Type>
  inline swig_type_info *type_info() {
    return traits_info<Type>::type_info();
  }

  /*
    Partial specialization for pointers (traits)
  */
  template <class Type> struct traits <Type *> {
    typedef pointer_category category;
    static std::string make_ptr_name(const char* name) {
      std::string ptrname = name;
      ptrname += " *";
      return ptrname;
    }
    static const char* type_name() {
      static std::string name = make_ptr_name(swig::type_name<Type>());
      return name.c_str();
    }
  };

  template <class Type, class Category>
  struct traits_as { };

  template <class Type, class Category>
  struct traits_check { };

}


namespace swig {  
  /*
    Traits that provides the from method
  */
  template <class Type> struct traits_from_ptr {
    static PyObject *from(Type *val, int owner = 0) {
      return SWIG_InternalNewPointerObj(val, type_info<Type>(), owner);
    }
  };

  template <class Type> struct traits_from {
    static PyObject *from(const Type& val) {
      return traits_from_ptr<Type>::from(new Type(val), 1);
    }
  };

  template <class Type> struct traits_from<Type *> {
    static PyObject *from(Type* val) {
      return traits_from_ptr<Type>::from(val, 0);
    }
  };

  template <class Type> struct traits_from<const Type *> {
    static PyObject *from(const Type* val) {
      return traits_from_ptr<Type>::from(const_cast<Type*>(val), 0);
    }
  };


  template <class Type>
  inline PyObject *from(const Type& val) {
    return traits_from<Type>::from(val);
  }

  template <class Type>
  inline PyObject *from_ptr(Type* val, int owner) {
    return traits_from_ptr<Type>::from(val, owner);
  }

  /*
    Traits that provides the asval/as/check method
  */
  template <class Type>
  struct traits_asptr {   
    static int asptr(PyObject *obj, Type **val) {
      int res = SWIG_ERROR;
      swig_type_info *descriptor = type_info<Type>();
      if (val) {
        Type *p = 0;
        int newmem = 0;
        res = descriptor ? SWIG_ConvertPtrAndOwn(obj, (void **)&p, descriptor, 0, &newmem) : SWIG_ERROR;
        if (SWIG_IsOK(res)) {
          if (newmem & SWIG_CAST_NEW_MEMORY) {
            res |= SWIG_NEWOBJMASK;
          }
          *val = p;
        }
      } else {
        res = descriptor ? SWIG_ConvertPtr(obj, 0, descriptor, 0) : SWIG_ERROR;
      }
      return res;
    }
  }; 

  template <class Type>
  inline int asptr(PyObject *obj, Type **vptr) {
    return traits_asptr<Type>::asptr(obj, vptr);
  }

  template <class Type> 
  struct traits_asval {
    static int asval(PyObject *obj, Type *val) {
      if (val) {
	Type *p = 0;
	int res = traits_asptr<Type>::asptr(obj, &p);
	if (!SWIG_IsOK(res)) return res;	
	if (p) {
	  typedef typename noconst_traits<Type>::noconst_type noconst_type;
	  *(const_cast<noconst_type*>(val)) = *p;
	  if (SWIG_IsNewObj(res)){
	    delete p;
	    res = SWIG_DelNewMask(res);
	  }
	  return res;
	} else {
	  return SWIG_ERROR;
	}
      } else {
	return traits_asptr<Type>::asptr(obj, (Type **)(0));
      }
    }
  };

  template <class Type> struct traits_asval<Type*> {
    static int asval(PyObject *obj, Type **val) {
      if (val) {
        typedef typename noconst_traits<Type>::noconst_type noconst_type;
        noconst_type *p = 0;
        int res = traits_asptr<noconst_type>::asptr(obj,  &p);
        if (SWIG_IsOK(res)) {
          *(const_cast<noconst_type**>(val)) = p;
	}
	return res;
      } else {
	return traits_asptr<Type>::asptr(obj, (Type **)(0));
      }
    }
  };
  
  template <class Type>
  inline int asval(PyObject *obj, Type *val) {
    return traits_asval<Type>::asval(obj, val);
  }

  template <class Type> 
  struct traits_as<Type, value_category> {
    static Type as(PyObject *obj) {
      Type v;
      int res = asval(obj, &v);
      if (!obj || !SWIG_IsOK(res)) {
	if (!PyErr_Occurred()) {
	  ::SWIG_Error(SWIG_TypeError,  swig::type_name<Type>());
	}
	throw std::invalid_argument("bad type");
      }
      return v;
    }
  };

  template <class Type> 
  struct traits_as<Type, pointer_category> {
    static Type as(PyObject *obj) {
      Type *v = 0;      
      int res = (obj ? traits_asptr<Type>::asptr(obj, &v) : SWIG_ERROR);
      if (SWIG_IsOK(res) && v) {
	if (SWIG_IsNewObj(res)) {
	  Type r(*v);
	  delete v;
	  return r;
	} else {
	  return *v;
	}
      } else {
	if (!PyErr_Occurred()) {
	  SWIG_Error(SWIG_TypeError,  swig::type_name<Type>());
	}
	throw std::invalid_argument("bad type");
      }
    }
  };

  template <class Type> 
  struct traits_as<Type*, pointer_category> {
    static Type* as(PyObject *obj) {
      Type *v = 0;      
      int res = (obj ? traits_asptr<Type>::asptr(obj, &v) : SWIG_ERROR);
      if (SWIG_IsOK(res)) {
	return v;
      } else {
	if (!PyErr_Occurred()) {
	  SWIG_Error(SWIG_TypeError,  swig::type_name<Type>());
	}
	throw std::invalid_argument("bad type");
      }
    }
  };
    
  template <class Type>
  inline Type as(PyObject *obj) {
    return traits_as<Type, typename traits<Type>::category>::as(obj);
  }

  template <class Type> 
  struct traits_check<Type, value_category> {
    static bool check(PyObject *obj) {
      int res = obj ? asval(obj, (Type *)(0)) : SWIG_ERROR;
      return SWIG_IsOK(res) ? true : false;
    }
  };

  template <class Type> 
  struct traits_check<Type, pointer_category> {
    static bool check(PyObject *obj) {
      int res = obj ? asptr(obj, (Type **)(0)) : SWIG_ERROR;
      return SWIG_IsOK(res) ? true : false;
    }
  };

  template <class Type>
  inline bool check(PyObject *obj) {
    return traits_check<Type, typename traits<Type>::category>::check(obj);
  }
}


#if defined(__SUNPRO_CC) && defined(_RWSTD_VER)
#  if !defined(SWIG_NO_STD_NOITERATOR_TRAITS_STL)
#    define SWIG_STD_NOITERATOR_TRAITS_STL
#  endif
#endif

#if !defined(SWIG_STD_NOITERATOR_TRAITS_STL)
#include <iterator>
#else
namespace std {
  template <class Iterator>
  struct iterator_traits {
    typedef ptrdiff_t difference_type;
    typedef typename Iterator::value_type value_type;
  };

  template <class Iterator, class Category,class T, class Reference, class Pointer, class Distance>
  struct iterator_traits<__reverse_bi_iterator<Iterator,Category,T,Reference,Pointer,Distance> > {
    typedef Distance difference_type;
    typedef T value_type;
  };

  template <class T>
  struct iterator_traits<T*> {
    typedef T value_type;
    typedef ptrdiff_t difference_type;
  };

  template<typename _InputIterator>
  inline typename iterator_traits<_InputIterator>::difference_type
  distance(_InputIterator __first, _InputIterator __last)
  {
    typename iterator_traits<_InputIterator>::difference_type __n = 0;
    while (__first != __last) {
      ++__first; ++__n;
    }
    return __n;
  }
}
#endif


namespace swig {
  template<typename OutIterator>
  class SwigPyIterator_T :  public SwigPyIterator
  {
  public:
    typedef OutIterator out_iterator;
    typedef typename std::iterator_traits<out_iterator>::value_type value_type;    
    typedef SwigPyIterator_T<out_iterator> self_type;

    SwigPyIterator_T(out_iterator curr, PyObject *seq)
      : SwigPyIterator(seq), current(curr)
    {
    }

    const out_iterator& get_current() const
    {
      return current;
    }

    
    bool equal (const SwigPyIterator &iter) const
    {
      const self_type *iters = dynamic_cast<const self_type *>(&iter);
      if (iters) {
	return (current == iters->get_current());
      } else {
	throw std::invalid_argument("bad iterator type");
      }
    }
    
    ptrdiff_t distance(const SwigPyIterator &iter) const
    {
      const self_type *iters = dynamic_cast<const self_type *>(&iter);
      if (iters) {
	return std::distance(current, iters->get_current());
      } else {
	throw std::invalid_argument("bad iterator type");
      }
    }    
    
  protected:
    out_iterator current;
  };
  
  template <class ValueType>
  struct from_oper 
  {
    typedef const ValueType& argument_type;
    typedef PyObject *result_type;
    result_type operator()(argument_type v) const
    {
      return swig::from(v);
    }
  };

  template<typename OutIterator, 
	   typename ValueType = typename std::iterator_traits<OutIterator>::value_type,
	   typename FromOper = from_oper<ValueType> >
  class SwigPyForwardIteratorOpen_T :  public SwigPyIterator_T<OutIterator>
  {
  public:
    FromOper from;
    typedef OutIterator out_iterator;
    typedef ValueType value_type;
    typedef SwigPyIterator_T<out_iterator>  base;
    typedef SwigPyForwardIteratorOpen_T<OutIterator, ValueType, FromOper> self_type;
    
    SwigPyForwardIteratorOpen_T(out_iterator curr, PyObject *seq)
      : SwigPyIterator_T<OutIterator>(curr, seq)
    {
    }
    
    PyObject *value() const {
      return from(static_cast<const value_type&>(*(base::current)));
    }
    
    SwigPyIterator *copy() const
    {
      return new self_type(*this);
    }

    SwigPyIterator *incr(size_t n = 1)
    {
      // Open iterator does not raise StopIteration
      while (n--) {
	++base::current;
      }
      return this;
    }

  };

  template<typename OutIterator, 
	   typename ValueType = typename std::iterator_traits<OutIterator>::value_type,
	   typename FromOper = from_oper<ValueType> >
  class SwigPyIteratorOpen_T :  public SwigPyForwardIteratorOpen_T<OutIterator, ValueType, FromOper>
  {
  public:
    FromOper from;
    typedef OutIterator out_iterator;
    typedef ValueType value_type;
    typedef SwigPyIterator_T<out_iterator>  base;
    typedef SwigPyIteratorOpen_T<OutIterator, ValueType, FromOper> self_type;
    
    SwigPyIteratorOpen_T(out_iterator curr, PyObject *seq)
      : SwigPyForwardIteratorOpen_T<OutIterator>(curr, seq)
    {
    }

    SwigPyIterator *decr(size_t n = 1)
    {
      // Open iterator does not raise StopIteration
      while (n--) {
	--base::current;
      }
      return this;
    }
  };

  template<typename OutIterator, 
	   typename ValueType = typename std::iterator_traits<OutIterator>::value_type,
	   typename FromOper = from_oper<ValueType> >
  class SwigPyForwardIteratorClosed_T :  public SwigPyIterator_T<OutIterator>
  {
  public:
    FromOper from;
    typedef OutIterator out_iterator;
    typedef ValueType value_type;
    typedef SwigPyIterator_T<out_iterator>  base;    
    typedef SwigPyForwardIteratorClosed_T<OutIterator, ValueType, FromOper> self_type;
    
    SwigPyForwardIteratorClosed_T(out_iterator curr, out_iterator first, out_iterator last, PyObject *seq)
      : SwigPyIterator_T<OutIterator>(curr, seq), begin(first), end(last)
    {
    }
    
    PyObject *value() const {
      if (base::current == end) {
	base::raise_stop_iteration();
	return NULL;
      } else {
	return from(static_cast<const value_type&>(*(base::current)));
      }
    }
    
    SwigPyIterator *copy() const
    {
      return new self_type(*this);
    }

    SwigPyIterator *incr(size_t n = 1)
    {
      while (n--) {
	if (base::current == end) {
	  base::raise_stop_iteration();
	  return NULL;
	} else {
	  ++base::current;
	}
      }
      return this;
    }

  protected:
    out_iterator begin;
    out_iterator end;
  };

  template<typename OutIterator, 
	   typename ValueType = typename std::iterator_traits<OutIterator>::value_type,
	   typename FromOper = from_oper<ValueType> >
  class SwigPyIteratorClosed_T :  public SwigPyForwardIteratorClosed_T<OutIterator,ValueType,FromOper>
  {
  public:
    FromOper from;
    typedef OutIterator out_iterator;
    typedef ValueType value_type;
    typedef SwigPyIterator_T<out_iterator>  base;
    typedef SwigPyForwardIteratorClosed_T<OutIterator, ValueType, FromOper> base0;
    typedef SwigPyIteratorClosed_T<OutIterator, ValueType, FromOper> self_type;
    
    SwigPyIteratorClosed_T(out_iterator curr, out_iterator first, out_iterator last, PyObject *seq)
      : SwigPyForwardIteratorClosed_T<OutIterator,ValueType,FromOper>(curr, first, last, seq)
    {
    }

    SwigPyIterator *decr(size_t n = 1)
    {
      while (n--) {
	if (base::current == base0::begin) {
	  base0::raise_stop_iteration();
	  return NULL;
	} else {
	  --base::current;
	}
      }
      return this;
    }
  };


  template<typename OutIter>
  inline SwigPyIterator*
  make_output_forward_iterator(const OutIter& current, const OutIter& begin,const OutIter& end, PyObject *seq = 0)
  {
    return new SwigPyForwardIteratorClosed_T<OutIter>(current, begin, end, seq);
  }

  template<typename OutIter>
  inline SwigPyIterator*
  make_output_iterator(const OutIter& current, const OutIter& begin,const OutIter& end, PyObject *seq = 0)
  {
    return new SwigPyIteratorClosed_T<OutIter>(current, begin, end, seq);
  }

  template<typename OutIter>
  inline SwigPyIterator*
  make_output_forward_iterator(const OutIter& current, PyObject *seq = 0)
  {
    return new SwigPyForwardIteratorOpen_T<OutIter>(current, seq);
  }

  template<typename OutIter>
  inline SwigPyIterator*
  make_output_iterator(const OutIter& current, PyObject *seq = 0)
  {
    return new SwigPyIteratorOpen_T<OutIter>(current, seq);
  }

}


  namespace swig {
    template <>  struct traits< sword::SWBuf > {
      typedef pointer_category category;
      static const char* type_name() { return"sword::SWBuf"; }
    };
  }


  namespace swig {


















































    template <class T, class U >
    struct traits_asptr<std::pair<T,U> >  {
      typedef std::pair<T,U> value_type;

      static int get_pair(PyObject* first, PyObject* second,
			  std::pair<T,U> **val) 
      {
	if (val) {
	  value_type *vp = (new std::pair<T,U>());
	  T *pfirst = &(vp->first);
	  int res1 = swig::asval((PyObject*)first, pfirst);
	  if (!SWIG_IsOK(res1)) {
	    delete vp;
	    return res1;
	  }
	  U *psecond = &(vp->second);
	  int res2 = swig::asval((PyObject*)second, psecond);
	  if (!SWIG_IsOK(res2)) {
	    delete vp;
	    return res2;
	  }
	  *val = vp;
	  return SWIG_AddNewMask(res1 > res2 ? res1 : res2);
	} else {
	  T *pfirst = 0;
	  int res1 = swig::asval((PyObject*)first, pfirst);
	  if (!SWIG_IsOK(res1)) return res1;
	  U *psecond = 0;
	  int res2 = swig::asval((PyObject*)second, psecond);
	  if (!SWIG_IsOK(res2)) return res2;
	  return res1 > res2 ? res1 : res2;
	}
      }

      static int asptr(PyObject *obj, std::pair<T,U> **val) {
	int res = SWIG_ERROR;
	if (PyTuple_Check(obj)) {
	  if (PyTuple_GET_SIZE(obj) == 2) {
	    res = get_pair(PyTuple_GET_ITEM(obj,0),PyTuple_GET_ITEM(obj,1), val);
	  }
	} else if (PySequence_Check(obj)) {
	  if (PySequence_Size(obj) == 2) {
	    swig::SwigVar_PyObject first = PySequence_GetItem(obj,0);
	    swig::SwigVar_PyObject second = PySequence_GetItem(obj,1);
	    res = get_pair(first, second, val);
	  }
	} else {
	  value_type *p = 0;
	  swig_type_info *descriptor = swig::type_info<value_type>();
	  res = descriptor ? SWIG_ConvertPtr(obj, (void **)&p, descriptor, 0) : SWIG_ERROR;
	  if (SWIG_IsOK(res) && val)  *val = p;
	}
	return res;
      }
    };


    template <class T, class U >
    struct traits_from<std::pair<T,U> >   {
      static PyObject *from(const std::pair<T,U>& val) {
	PyObject* obj = PyTuple_New(2);
	PyTuple_SetItem(obj,0,swig::from(val.first));
	PyTuple_SetItem(obj,1,swig::from(val.second));
	return obj;
      }
    };
  }





































      namespace swig {
	template <>  struct traits<std::pair< sword::SWBuf, sword::SWBuf > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::pair<" "sword::SWBuf" "," "sword::SWBuf" " >";
	  }
	};
      }
    

#include <functional>

namespace std {
  template <>
  struct less <PyObject *>
  {
    bool
    operator()(PyObject * v, PyObject *w) const
    { 
      bool res;
      SWIG_PYTHON_THREAD_BEGIN_BLOCK;
      res = PyObject_RichCompareBool(v, w, Py_LT) ? true : false;
      /* This may fall into a case of inconsistent
               eg. ObjA > ObjX > ObjB
               but ObjA < ObjB
      */
      if( PyErr_Occurred() && PyErr_ExceptionMatches(PyExc_TypeError) )
      {
        /* Objects can't be compared, this mostly occurred in Python 3.0 */
        /* Compare their ptr directly for a workaround */
        res = (v < w);
        PyErr_Clear();
      }
      SWIG_PYTHON_THREAD_END_BLOCK;
      return res;
    }
  };

  template <>
  struct less <swig::SwigPtr_PyObject>
  {
    bool
    operator()(const swig::SwigPtr_PyObject& v, const swig::SwigPtr_PyObject& w) const
    {
      return std::less<PyObject *>()(v, w);
    }
  };

  template <>
  struct less <swig::SwigVar_PyObject>
  {
    bool
    operator()(const swig::SwigVar_PyObject& v, const swig::SwigVar_PyObject& w) const
    {
      return std::less<PyObject *>()(v, w);
    }
  };

}

namespace swig {
  template <> struct traits<PyObject *> {
    typedef value_category category;
    static const char* type_name() { return "PyObject *"; }
  };  

  template <>  struct traits_asval<PyObject * > {   
    typedef PyObject * value_type;
    static int asval(PyObject *obj, value_type *val) {
      if (val) *val = obj;
      return SWIG_OK;
    }
  };

  template <> 
  struct traits_check<PyObject *, value_category> {
    static bool check(PyObject *) {
      return true;
    }
  };

  template <>  struct traits_from<PyObject *> {
    typedef PyObject * value_type;
    static PyObject *from(const value_type& val) {
      SWIG_Py_XINCREF(val);
      return val;
    }
  };
  
}

namespace swig {
  template <class Difference>
  inline size_t
  check_index(Difference i, size_t size, bool insert = false) {
    if ( i < 0 ) {
      if ((size_t) (-i) <= size)
	return (size_t) (i + size);
    } else if ( (size_t) i < size ) {
      return (size_t) i;
    } else if (insert && ((size_t) i == size)) {
      return size;
    }
    throw std::out_of_range("index out of range");
  }

  template <class Difference>
  void
  slice_adjust(Difference i, Difference j, Py_ssize_t step, size_t size, Difference &ii, Difference &jj, bool insert = false) {
    if (step == 0) {
      throw std::invalid_argument("slice step cannot be zero");
    } else if (step > 0) {
      // Required range: 0 <= i < size, 0 <= j < size, i <= j
      if (i < 0) {
        ii = 0;
      } else if (i < (Difference)size) {
        ii = i;
      } else if (insert && (i >= (Difference)size)) {
        ii = (Difference)size;
      }
      if (j < 0) {
        jj = 0;
      } else {
        jj = (j < (Difference)size) ? j : (Difference)size;
      }
      if (jj < ii)
        jj = ii;
    } else {
      // Required range: -1 <= i < size-1, -1 <= j < size-1, i >= j
      if (i < -1) {
        ii = -1;
      } else if (i < (Difference) size) {
        ii = i;
      } else if (i >= (Difference)(size-1)) {
        ii = (Difference)(size-1);
      }
      if (j < -1) {
        jj = -1;
      } else {
        jj = (j < (Difference)size ) ? j : (Difference)(size-1);
      }
      if (ii < jj)
        ii = jj;
    }
  }

  template <class Sequence, class Difference>
  inline typename Sequence::iterator
  getpos(Sequence* self, Difference i)  {
    typename Sequence::iterator pos = self->begin();
    std::advance(pos, check_index(i,self->size()));
    return pos;
  }

  template <class Sequence, class Difference>
  inline typename Sequence::const_iterator
  cgetpos(const Sequence* self, Difference i)  {
    typename Sequence::const_iterator pos = self->begin();
    std::advance(pos, check_index(i,self->size()));
    return pos;
  }

  template <class Sequence>
  inline void
  erase(Sequence* seq, const typename Sequence::iterator& position) {
    seq->erase(position);
  }

  template <class Sequence>
  struct traits_reserve {
    static void reserve(Sequence & /*seq*/, typename Sequence::size_type /*n*/) {
      // This should be specialized for types that support reserve
    }
  };

  template <class Sequence, class Difference>
  inline Sequence*
  getslice(const Sequence* self, Difference i, Difference j, Py_ssize_t step) {
    typename Sequence::size_type size = self->size();
    Difference ii = 0;
    Difference jj = 0;
    swig::slice_adjust(i, j, step, size, ii, jj);

    if (step > 0) {
      typename Sequence::const_iterator sb = self->begin();
      typename Sequence::const_iterator se = self->begin();
      std::advance(sb,ii);
      std::advance(se,jj);
      if (step == 1) {
        return new Sequence(sb, se);
      } else {
        Sequence *sequence = new Sequence();
        swig::traits_reserve<Sequence>::reserve(*sequence, (jj - ii + step - 1) / step);
        typename Sequence::const_iterator it = sb;
        while (it!=se) {
          sequence->push_back(*it);
          for (Py_ssize_t c=0; c<step && it!=se; ++c)
            it++;
        }
        return sequence;
      } 
    } else {
      Sequence *sequence = new Sequence();
      swig::traits_reserve<Sequence>::reserve(*sequence, (ii - jj - step - 1) / -step);
      typename Sequence::const_reverse_iterator sb = self->rbegin();
      typename Sequence::const_reverse_iterator se = self->rbegin();
      std::advance(sb,size-ii-1);
      std::advance(se,size-jj-1);
      typename Sequence::const_reverse_iterator it = sb;
      while (it!=se) {
        sequence->push_back(*it);
        for (Py_ssize_t c=0; c<-step && it!=se; ++c)
          it++;
      }
      return sequence;
    }
  }

  template <class Sequence, class Difference, class InputSeq>
  inline void
  setslice(Sequence* self, Difference i, Difference j, Py_ssize_t step, const InputSeq& is = InputSeq()) {
    typename Sequence::size_type size = self->size();
    Difference ii = 0;
    Difference jj = 0;
    swig::slice_adjust(i, j, step, size, ii, jj, true);
    if (step > 0) {
      if (step == 1) {
        size_t ssize = jj - ii;
        if (ssize <= is.size()) {
          // expanding/staying the same size
          swig::traits_reserve<Sequence>::reserve(*self, self->size() - ssize + is.size());
          typename Sequence::iterator sb = self->begin();
          typename InputSeq::const_iterator isit = is.begin();
          std::advance(sb,ii);
          std::advance(isit, jj - ii);
          self->insert(std::copy(is.begin(), isit, sb), isit, is.end());
        } else {
          // shrinking
          typename Sequence::iterator sb = self->begin();
          typename Sequence::iterator se = self->begin();
          std::advance(sb,ii);
          std::advance(se,jj);
          self->erase(sb,se);
          sb = self->begin();
          std::advance(sb,ii);
          self->insert(sb, is.begin(), is.end());
        }
      } else {
        size_t replacecount = (jj - ii + step - 1) / step;
        if (is.size() != replacecount) {
          char msg[1024];
          PyOS_snprintf(msg, sizeof(msg), "attempt to assign sequence of size %lu to extended slice of size %lu", (unsigned long)is.size(), (unsigned long)replacecount);
          throw std::invalid_argument(msg);
        }
        typename Sequence::const_iterator isit = is.begin();
        typename Sequence::iterator it = self->begin();
        std::advance(it,ii);
        for (size_t rc=0; rc<replacecount && it != self->end(); ++rc) {
          *it++ = *isit++;
          for (Py_ssize_t c=0; c<(step-1) && it != self->end(); ++c)
            it++;
        }
      }
    } else {
      size_t replacecount = (ii - jj - step - 1) / -step;
      if (is.size() != replacecount) {
        char msg[1024];
        PyOS_snprintf(msg, sizeof(msg), "attempt to assign sequence of size %lu to extended slice of size %lu", (unsigned long)is.size(), (unsigned long)replacecount);
        throw std::invalid_argument(msg);
      }
      typename Sequence::const_iterator isit = is.begin();
      typename Sequence::reverse_iterator it = self->rbegin();
      std::advance(it,size-ii-1);
      for (size_t rc=0; rc<replacecount && it != self->rend(); ++rc) {
        *it++ = *isit++;
        for (Py_ssize_t c=0; c<(-step-1) && it != self->rend(); ++c)
          it++;
      }
    }
  }

  template <class Sequence, class Difference>
  inline void
  delslice(Sequence* self, Difference i, Difference j, Py_ssize_t step) {
    typename Sequence::size_type size = self->size();
    Difference ii = 0;
    Difference jj = 0;
    swig::slice_adjust(i, j, step, size, ii, jj, true);
    if (step > 0) {
      typename Sequence::iterator sb = self->begin();
      std::advance(sb,ii);
      if (step == 1) {
        typename Sequence::iterator se = self->begin();
        std::advance(se,jj);
        self->erase(sb,se);
      } else {
        typename Sequence::iterator it = sb;
        size_t delcount = (jj - ii + step - 1) / step;
        while (delcount) {
          it = self->erase(it);
          for (Py_ssize_t c=0; c<(step-1) && it != self->end(); ++c)
            it++;
          delcount--;
        }
      }
    } else {
      typename Sequence::reverse_iterator sb = self->rbegin();
      std::advance(sb,size-ii-1);
      typename Sequence::reverse_iterator it = sb;
      size_t delcount = (ii - jj - step - 1) / -step;
      while (delcount) {
        it = typename Sequence::reverse_iterator(self->erase((++it).base()));
        for (Py_ssize_t c=0; c<(-step-1) && it != self->rend(); ++c)
          it++;
        delcount--;
      }
    }
  }
}


namespace swig {
  template <class Seq, class T = typename Seq::value_type >
  struct IteratorProtocol {
    static void assign(PyObject *obj, Seq *seq) {
      SwigVar_PyObject iter = PyObject_GetIter(obj);
      if (iter) {
        SwigVar_PyObject item = PyIter_Next(iter);
        while (item) {
          seq->insert(seq->end(), swig::as<T>(item));
          item = PyIter_Next(iter);
        }
      }
    }

    static bool check(PyObject *obj) {
      bool ret = false;
      SwigVar_PyObject iter = PyObject_GetIter(obj);
      if (iter) {
        SwigVar_PyObject item = PyIter_Next(iter);
        ret = true;
        while (item) {
          ret = swig::check<T>(item);
          item = ret ? PyIter_Next(iter) : 0;
        }
      }
      return ret;
    }
  };

  template <class Seq, class T = typename Seq::value_type >
  struct traits_asptr_stdseq {
    typedef Seq sequence;
    typedef T value_type;

    static bool is_iterable(PyObject *obj) {
      SwigVar_PyObject iter = PyObject_GetIter(obj);
      PyErr_Clear();
      return iter != 0;
    }

    static int asptr(PyObject *obj, sequence **seq) {
      int ret = SWIG_ERROR;
      if (obj == Py_None || SWIG_Python_GetSwigThis(obj)) {
	sequence *p;
	swig_type_info *descriptor = swig::type_info<sequence>();
	if (descriptor && SWIG_IsOK(::SWIG_ConvertPtr(obj, (void **)&p, descriptor, 0))) {
	  if (seq) *seq = p;
	  return SWIG_OLDOBJ;
	}
      } else if (is_iterable(obj)) {
	try {
	  if (seq) {
	    *seq = new sequence();
            IteratorProtocol<Seq, T>::assign(obj, *seq);
            if (!PyErr_Occurred())
              return SWIG_NEWOBJ;
	  } else {
	    return IteratorProtocol<Seq, T>::check(obj) ? SWIG_OK : SWIG_ERROR;
	  }
	} catch (std::exception& e) {
          if (seq && !PyErr_Occurred())
            PyErr_SetString(PyExc_TypeError, e.what());
	}
        if (seq)
          delete *seq;
	return SWIG_ERROR;
      }
      return ret;
    }
  };

  template <class Seq, class T = typename Seq::value_type >
  struct traits_from_stdseq {
    typedef Seq sequence;
    typedef T value_type;
    typedef typename Seq::size_type size_type;
    typedef typename sequence::const_iterator const_iterator;

    static PyObject *from(const sequence& seq) {
#ifdef SWIG_PYTHON_EXTRA_NATIVE_CONTAINERS
      swig_type_info *desc = swig::type_info<sequence>();
      if (desc && desc->clientdata) {
	return SWIG_InternalNewPointerObj(new sequence(seq), desc, SWIG_POINTER_OWN);
      }
#endif
      size_type size = seq.size();
      if (size <= (size_type)PY_SSIZE_T_MAX) {
	PyObject *obj = PyTuple_New((Py_ssize_t)size);
	Py_ssize_t i = 0;
	for (const_iterator it = seq.begin(); it != seq.end(); ++it, ++i) {
	  PyTuple_SetItem(obj,i,swig::from<value_type>(*it));
	}
	return obj;
      } else {
	PyErr_SetString(PyExc_OverflowError,"sequence size not valid in python");
	return NULL;
      }
    }
  };
}


  namespace swig {
    template <class ValueType>
    struct from_key_oper 
    {
      typedef const ValueType& argument_type;
      typedef  PyObject *result_type;
      result_type operator()(argument_type v) const
      {
	return swig::from(v.first);
      }
    };

    template <class ValueType>
    struct from_value_oper 
    {
      typedef const ValueType& argument_type;
      typedef  PyObject *result_type;
      result_type operator()(argument_type v) const
      {
	return swig::from(v.second);
      }
    };

    template<class OutIterator, class FromOper, class ValueType = typename OutIterator::value_type>
    struct SwigPyMapIterator_T : SwigPyIteratorClosed_T<OutIterator, ValueType, FromOper>
    {
      SwigPyMapIterator_T(OutIterator curr, OutIterator first, OutIterator last, PyObject *seq)
	: SwigPyIteratorClosed_T<OutIterator,ValueType,FromOper>(curr, first, last, seq)
      {
      }
    };


    template<class OutIterator,
	     class FromOper = from_key_oper<typename OutIterator::value_type> >
    struct SwigPyMapKeyIterator_T : SwigPyMapIterator_T<OutIterator, FromOper>
    {
      SwigPyMapKeyIterator_T(OutIterator curr, OutIterator first, OutIterator last, PyObject *seq)
	: SwigPyMapIterator_T<OutIterator, FromOper>(curr, first, last, seq)
      {
      }
    };

    template<typename OutIter>
    inline SwigPyIterator*
    make_output_key_iterator(const OutIter& current, const OutIter& begin, const OutIter& end, PyObject *seq = 0)
    {
      return new SwigPyMapKeyIterator_T<OutIter>(current, begin, end, seq);
    }

    template<class OutIterator,
	     class FromOper = from_value_oper<typename OutIterator::value_type> >
    struct SwigPyMapValueIterator_T : SwigPyMapIterator_T<OutIterator, FromOper>
    {
      SwigPyMapValueIterator_T(OutIterator curr, OutIterator first, OutIterator last, PyObject *seq)
	: SwigPyMapIterator_T<OutIterator, FromOper>(curr, first, last, seq)
      {
      }
    };
    

    template<typename OutIter>
    inline SwigPyIterator*
    make_output_value_iterator(const OutIter& current, const OutIter& begin, const OutIter& end, PyObject *seq = 0)
    {
      return new SwigPyMapValueIterator_T<OutIter>(current, begin, end, seq);
    }
  }


  namespace swig {
    template <class K, class T, class Compare, class Alloc>
    struct traits_asptr<std::map<K,T,Compare,Alloc > >  {
      typedef std::map<K,T,Compare,Alloc > map_type;
      static int asptr(PyObject *obj, map_type **val) {
	int res = SWIG_ERROR;
	SWIG_PYTHON_THREAD_BEGIN_BLOCK;
	if (PyDict_Check(obj)) {
	  SwigVar_PyObject items = PyObject_CallMethod(obj,(char *)"items",NULL);
#if PY_VERSION_HEX >= 0x03000000
          /* In Python 3.x the ".items()" method returns a dict_items object */
          items = PySequence_Fast(items, ".items() didn't return a sequence!");
#endif
	  res = traits_asptr_stdseq<map_type, std::pair<K, T> >::asptr(items, val);
	} else {
	  map_type *p = 0;
	  swig_type_info *descriptor = swig::type_info<map_type>();
	  res = descriptor ? SWIG_ConvertPtr(obj, (void **)&p, descriptor, 0) : SWIG_ERROR;
	  if (SWIG_IsOK(res) && val)  *val = p;
	}
	SWIG_PYTHON_THREAD_END_BLOCK;
	return res;
      }      
    };
      
    template <class K, class T, class Compare, class Alloc >
    struct traits_from<std::map<K,T,Compare,Alloc > >  {
      typedef std::map<K,T,Compare,Alloc > map_type;
      typedef typename map_type::const_iterator const_iterator;
      typedef typename map_type::size_type size_type;

      static PyObject *asdict(const map_type& map) {
	SWIG_PYTHON_THREAD_BEGIN_BLOCK;
	size_type size = map.size();
	Py_ssize_t pysize = (size <= (size_type)PY_SSIZE_T_MAX) ? (Py_ssize_t)size : -1;
	if (pysize < 0) {
	  PyErr_SetString(PyExc_OverflowError, "map size not valid in python");
	  SWIG_PYTHON_THREAD_END_BLOCK;
	  return NULL;
	}
	PyObject *obj = PyDict_New();
	for (const_iterator i= map.begin(); i!= map.end(); ++i) {
	  swig::SwigVar_PyObject key = swig::from(i->first);
	  swig::SwigVar_PyObject val = swig::from(i->second);
	  PyDict_SetItem(obj, key, val);
	}
	SWIG_PYTHON_THREAD_END_BLOCK;
	return obj;
      }
                
      static PyObject *from(const map_type& map) {
	swig_type_info *desc = swig::type_info<map_type>();
	if (desc && desc->clientdata) {
	  return SWIG_InternalNewPointerObj(new map_type(map), desc, SWIG_POINTER_OWN);
	} else {
	  return asdict(map);
	}
      }
    };
  }


      namespace swig {
	template <>  struct traits<std::map< sword::SWBuf, sword::SWBuf, std::less< sword::SWBuf >, std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::map<" "sword::SWBuf" "," "sword::SWBuf" "," "std::less< sword::SWBuf >" "," "std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > >" " >";
	  }
	};
      }
    
SWIGINTERN swig::SwigPyIterator *std_map_Sl_sword_SWBuf_Sc_sword_SWBuf_Sg__iterator(std::map< sword::SWBuf,sword::SWBuf > *self,PyObject **PYTHON_SELF){
      return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
    }
SWIGINTERN bool std_map_Sl_sword_SWBuf_Sc_sword_SWBuf_Sg____nonzero__(std::map< sword::SWBuf,sword::SWBuf > const *self){
      return !(self->empty());
    }
SWIGINTERN bool std_map_Sl_sword_SWBuf_Sc_sword_SWBuf_Sg____bool__(std::map< sword::SWBuf,sword::SWBuf > const *self){
      return !(self->empty());
    }
SWIGINTERN std::map< sword::SWBuf,sword::SWBuf >::size_type std_map_Sl_sword_SWBuf_Sc_sword_SWBuf_Sg____len__(std::map< sword::SWBuf,sword::SWBuf > const *self){
      return self->size();
    }

#ifdef SWIG_LONG_LONG_AVAILABLE
SWIGINTERNINLINE PyObject* 
SWIG_From_unsigned_SS_long_SS_long  (unsigned long long value)
{
  return (value > LONG_MAX) ?
    PyLong_FromUnsignedLongLong(value) : PyInt_FromLong(static_cast< long >(value));
}
#endif


SWIGINTERNINLINE PyObject *
SWIG_From_size_t  (size_t value)
{    
#ifdef SWIG_LONG_LONG_AVAILABLE
  if (sizeof(size_t) <= sizeof(unsigned long)) {
#endif
    return SWIG_From_unsigned_SS_long  (static_cast< unsigned long >(value));
#ifdef SWIG_LONG_LONG_AVAILABLE
  } else {
    /* assume sizeof(size_t) <= sizeof(unsigned long long) */
    return SWIG_From_unsigned_SS_long_SS_long  (static_cast< unsigned long long >(value));
  }
#endif
}

SWIGINTERN std::map< sword::SWBuf,sword::SWBuf >::mapped_type const &std_map_Sl_sword_SWBuf_Sc_sword_SWBuf_Sg____getitem__(std::map< sword::SWBuf,sword::SWBuf > *self,std::map< sword::SWBuf,sword::SWBuf >::key_type const &key){
      std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >::const_iterator i = self->find(key);
      if (i != self->end())
	return i->second;
      else
	throw std::out_of_range("key not found");
    }
SWIGINTERN void std_map_Sl_sword_SWBuf_Sc_sword_SWBuf_Sg____delitem__(std::map< sword::SWBuf,sword::SWBuf > *self,std::map< sword::SWBuf,sword::SWBuf >::key_type const &key){
      std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >::iterator i = self->find(key);
      if (i != self->end())
	self->erase(i);
      else
	throw std::out_of_range("key not found");
    }
SWIGINTERN bool std_map_Sl_sword_SWBuf_Sc_sword_SWBuf_Sg__has_key(std::map< sword::SWBuf,sword::SWBuf > const *self,std::map< sword::SWBuf,sword::SWBuf >::key_type const &key){
      std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >::const_iterator i = self->find(key);
      return i != self->end();
    }
SWIGINTERN PyObject *std_map_Sl_sword_SWBuf_Sc_sword_SWBuf_Sg__keys(std::map< sword::SWBuf,sword::SWBuf > *self){
      std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >::size_type size = self->size();
      Py_ssize_t pysize = (size <= (std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >::size_type)PY_SSIZE_T_MAX) ? (Py_ssize_t)size : -1;
      SWIG_PYTHON_THREAD_BEGIN_BLOCK;
      if (pysize < 0) {
	PyErr_SetString(PyExc_OverflowError, "map size not valid in python");
	SWIG_PYTHON_THREAD_END_BLOCK;
	return NULL;
      }
      PyObject* keyList = PyList_New(pysize);
      std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >::const_iterator i = self->begin();
      for (Py_ssize_t j = 0; j < pysize; ++i, ++j) {
	PyList_SET_ITEM(keyList, j, swig::from(i->first));
      }
      SWIG_PYTHON_THREAD_END_BLOCK;
      return keyList;
    }
SWIGINTERN PyObject *std_map_Sl_sword_SWBuf_Sc_sword_SWBuf_Sg__values(std::map< sword::SWBuf,sword::SWBuf > *self){
      std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >::size_type size = self->size();
      Py_ssize_t pysize = (size <= (std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >::size_type)PY_SSIZE_T_MAX) ? (Py_ssize_t)size : -1;
      SWIG_PYTHON_THREAD_BEGIN_BLOCK;
      if (pysize < 0) {
	PyErr_SetString(PyExc_OverflowError, "map size not valid in python");
	SWIG_PYTHON_THREAD_END_BLOCK;
	return NULL;
      }
      PyObject* valList = PyList_New(pysize);
      std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >::const_iterator i = self->begin();
      for (Py_ssize_t j = 0; j < pysize; ++i, ++j) {
	PyList_SET_ITEM(valList, j, swig::from(i->second));
      }
      SWIG_PYTHON_THREAD_END_BLOCK;
      return valList;
    }
SWIGINTERN PyObject *std_map_Sl_sword_SWBuf_Sc_sword_SWBuf_Sg__items(std::map< sword::SWBuf,sword::SWBuf > *self){
      std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >::size_type size = self->size();
      Py_ssize_t pysize = (size <= (std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >::size_type)PY_SSIZE_T_MAX) ? (Py_ssize_t)size : -1;
      SWIG_PYTHON_THREAD_BEGIN_BLOCK;
      if (pysize < 0) {
	PyErr_SetString(PyExc_OverflowError, "map size not valid in python");
	SWIG_PYTHON_THREAD_END_BLOCK;
	return NULL;
      }    
      PyObject* itemList = PyList_New(pysize);
      std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >::const_iterator i = self->begin();
      for (Py_ssize_t j = 0; j < pysize; ++i, ++j) {
	PyList_SET_ITEM(itemList, j, swig::from(*i));
      }
      SWIG_PYTHON_THREAD_END_BLOCK;
      return itemList;
    }
SWIGINTERN bool std_map_Sl_sword_SWBuf_Sc_sword_SWBuf_Sg____contains__(std::map< sword::SWBuf,sword::SWBuf > *self,std::map< sword::SWBuf,sword::SWBuf >::key_type const &key){
      return self->find(key) != self->end();
    }
SWIGINTERN swig::SwigPyIterator *std_map_Sl_sword_SWBuf_Sc_sword_SWBuf_Sg__key_iterator(std::map< sword::SWBuf,sword::SWBuf > *self,PyObject **PYTHON_SELF){
      return swig::make_output_key_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
    }
SWIGINTERN swig::SwigPyIterator *std_map_Sl_sword_SWBuf_Sc_sword_SWBuf_Sg__value_iterator(std::map< sword::SWBuf,sword::SWBuf > *self,PyObject **PYTHON_SELF){
      return swig::make_output_value_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
    }
SWIGINTERN void std_map_Sl_sword_SWBuf_Sc_sword_SWBuf_Sg____setitem____SWIG_0(std::map< sword::SWBuf,sword::SWBuf > *self,std::map< sword::SWBuf,sword::SWBuf >::key_type const &key){
      self->erase(key);
    }
SWIGINTERN void std_map_Sl_sword_SWBuf_Sc_sword_SWBuf_Sg____setitem____SWIG_1(std::map< sword::SWBuf,sword::SWBuf > *self,std::map< sword::SWBuf,sword::SWBuf >::key_type const &key,std::map< sword::SWBuf,sword::SWBuf >::mapped_type const &x){
#ifdef __cpp_lib_map_try_emplace
      (*self).insert_or_assign(key, x);
#else
      (*self)[key] = x;
#endif
    }
SWIGINTERN PyObject *std_map_Sl_sword_SWBuf_Sc_sword_SWBuf_Sg__asdict(std::map< sword::SWBuf,sword::SWBuf > *self){
      return swig::traits_from< std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > >::asdict(*self);
    }
SWIGINTERN void std_map_Sl_sword_SWBuf_Sc_sword_SWBuf_Sg__erase__SWIG_1(std::map< sword::SWBuf,sword::SWBuf > *self,std::map< sword::SWBuf,sword::SWBuf >::iterator position){ self->erase(position); }
SWIGINTERN void std_map_Sl_sword_SWBuf_Sc_sword_SWBuf_Sg__erase__SWIG_2(std::map< sword::SWBuf,sword::SWBuf > *self,std::map< sword::SWBuf,sword::SWBuf >::iterator first,std::map< sword::SWBuf,sword::SWBuf >::iterator last){ self->erase(first, last); }

      namespace swig {
	template <>  struct traits<std::pair< sword::SWBuf, std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::pair<" "sword::SWBuf" "," "std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >" " >";
	  }
	};
      }
    

      namespace swig {
	template <>  struct traits<std::map< sword::SWBuf, std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >, std::less< sword::SWBuf >, std::allocator< std::pair< sword::SWBuf const,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > > > > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::map<" "sword::SWBuf" "," "std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >" "," "std::less< sword::SWBuf >" "," "std::allocator< std::pair< sword::SWBuf const,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > > >" " >";
	  }
	};
      }
    
SWIGINTERN swig::SwigPyIterator *std_map_Sl_sword_SWBuf_Sc_AttributeValueMap_Sg__iterator(std::map< sword::SWBuf,AttributeValueMap > *self,PyObject **PYTHON_SELF){
      return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
    }
SWIGINTERN bool std_map_Sl_sword_SWBuf_Sc_AttributeValueMap_Sg____nonzero__(std::map< sword::SWBuf,AttributeValueMap > const *self){
      return !(self->empty());
    }
SWIGINTERN bool std_map_Sl_sword_SWBuf_Sc_AttributeValueMap_Sg____bool__(std::map< sword::SWBuf,AttributeValueMap > const *self){
      return !(self->empty());
    }
SWIGINTERN std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > >::size_type std_map_Sl_sword_SWBuf_Sc_AttributeValueMap_Sg____len__(std::map< sword::SWBuf,AttributeValueMap > const *self){
      return self->size();
    }
SWIGINTERN std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > >::mapped_type const &std_map_Sl_sword_SWBuf_Sc_AttributeValueMap_Sg____getitem__(std::map< sword::SWBuf,AttributeValueMap > *self,std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > >::key_type const &key){
      std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > > > >::const_iterator i = self->find(key);
      if (i != self->end())
	return i->second;
      else
	throw std::out_of_range("key not found");
    }
SWIGINTERN void std_map_Sl_sword_SWBuf_Sc_AttributeValueMap_Sg____delitem__(std::map< sword::SWBuf,AttributeValueMap > *self,std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > >::key_type const &key){
      std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > > > >::iterator i = self->find(key);
      if (i != self->end())
	self->erase(i);
      else
	throw std::out_of_range("key not found");
    }
SWIGINTERN bool std_map_Sl_sword_SWBuf_Sc_AttributeValueMap_Sg__has_key(std::map< sword::SWBuf,AttributeValueMap > const *self,std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > >::key_type const &key){
      std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > > > >::const_iterator i = self->find(key);
      return i != self->end();
    }
SWIGINTERN PyObject *std_map_Sl_sword_SWBuf_Sc_AttributeValueMap_Sg__keys(std::map< sword::SWBuf,AttributeValueMap > *self){
      std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > > > >::size_type size = self->size();
      Py_ssize_t pysize = (size <= (std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > > > >::size_type)PY_SSIZE_T_MAX) ? (Py_ssize_t)size : -1;
      SWIG_PYTHON_THREAD_BEGIN_BLOCK;
      if (pysize < 0) {
	PyErr_SetString(PyExc_OverflowError, "map size not valid in python");
	SWIG_PYTHON_THREAD_END_BLOCK;
	return NULL;
      }
      PyObject* keyList = PyList_New(pysize);
      std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > > > >::const_iterator i = self->begin();
      for (Py_ssize_t j = 0; j < pysize; ++i, ++j) {
	PyList_SET_ITEM(keyList, j, swig::from(i->first));
      }
      SWIG_PYTHON_THREAD_END_BLOCK;
      return keyList;
    }
SWIGINTERN PyObject *std_map_Sl_sword_SWBuf_Sc_AttributeValueMap_Sg__values(std::map< sword::SWBuf,AttributeValueMap > *self){
      std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > > > >::size_type size = self->size();
      Py_ssize_t pysize = (size <= (std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > > > >::size_type)PY_SSIZE_T_MAX) ? (Py_ssize_t)size : -1;
      SWIG_PYTHON_THREAD_BEGIN_BLOCK;
      if (pysize < 0) {
	PyErr_SetString(PyExc_OverflowError, "map size not valid in python");
	SWIG_PYTHON_THREAD_END_BLOCK;
	return NULL;
      }
      PyObject* valList = PyList_New(pysize);
      std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > > > >::const_iterator i = self->begin();
      for (Py_ssize_t j = 0; j < pysize; ++i, ++j) {
	PyList_SET_ITEM(valList, j, swig::from(i->second));
      }
      SWIG_PYTHON_THREAD_END_BLOCK;
      return valList;
    }
SWIGINTERN PyObject *std_map_Sl_sword_SWBuf_Sc_AttributeValueMap_Sg__items(std::map< sword::SWBuf,AttributeValueMap > *self){
      std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > > > >::size_type size = self->size();
      Py_ssize_t pysize = (size <= (std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > > > >::size_type)PY_SSIZE_T_MAX) ? (Py_ssize_t)size : -1;
      SWIG_PYTHON_THREAD_BEGIN_BLOCK;
      if (pysize < 0) {
	PyErr_SetString(PyExc_OverflowError, "map size not valid in python");
	SWIG_PYTHON_THREAD_END_BLOCK;
	return NULL;
      }    
      PyObject* itemList = PyList_New(pysize);
      std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > > > >::const_iterator i = self->begin();
      for (Py_ssize_t j = 0; j < pysize; ++i, ++j) {
	PyList_SET_ITEM(itemList, j, swig::from(*i));
      }
      SWIG_PYTHON_THREAD_END_BLOCK;
      return itemList;
    }
SWIGINTERN bool std_map_Sl_sword_SWBuf_Sc_AttributeValueMap_Sg____contains__(std::map< sword::SWBuf,AttributeValueMap > *self,std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > >::key_type const &key){
      return self->find(key) != self->end();
    }
SWIGINTERN swig::SwigPyIterator *std_map_Sl_sword_SWBuf_Sc_AttributeValueMap_Sg__key_iterator(std::map< sword::SWBuf,AttributeValueMap > *self,PyObject **PYTHON_SELF){
      return swig::make_output_key_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
    }
SWIGINTERN swig::SwigPyIterator *std_map_Sl_sword_SWBuf_Sc_AttributeValueMap_Sg__value_iterator(std::map< sword::SWBuf,AttributeValueMap > *self,PyObject **PYTHON_SELF){
      return swig::make_output_value_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
    }
SWIGINTERN void std_map_Sl_sword_SWBuf_Sc_AttributeValueMap_Sg____setitem____SWIG_0(std::map< sword::SWBuf,AttributeValueMap > *self,std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > >::key_type const &key){
      self->erase(key);
    }
SWIGINTERN void std_map_Sl_sword_SWBuf_Sc_AttributeValueMap_Sg____setitem____SWIG_1(std::map< sword::SWBuf,AttributeValueMap > *self,std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > >::key_type const &key,std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > >::mapped_type const &x){
#ifdef __cpp_lib_map_try_emplace
      (*self).insert_or_assign(key, x);
#else
      (*self)[key] = x;
#endif
    }
SWIGINTERN PyObject *std_map_Sl_sword_SWBuf_Sc_AttributeValueMap_Sg__asdict(std::map< sword::SWBuf,AttributeValueMap > *self){
      return swig::traits_from< std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > > > > >::asdict(*self);
    }
SWIGINTERN void std_map_Sl_sword_SWBuf_Sc_AttributeValueMap_Sg__erase__SWIG_1(std::map< sword::SWBuf,AttributeValueMap > *self,std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > >::iterator position){ self->erase(position); }
SWIGINTERN void std_map_Sl_sword_SWBuf_Sc_AttributeValueMap_Sg__erase__SWIG_2(std::map< sword::SWBuf,AttributeValueMap > *self,std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > >::iterator first,std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > >::iterator last){ self->erase(first, last); }

      namespace swig {
	template <>  struct traits<std::pair< sword::SWBuf, std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > > > > > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::pair<" "sword::SWBuf" "," "std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > > > >" " >";
	  }
	};
      }
    

      namespace swig {
	template <>  struct traits<std::map< sword::SWBuf, std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > > > >, std::less< sword::SWBuf >, std::allocator< std::pair< sword::SWBuf const,std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > > > > > > > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::map<" "sword::SWBuf" "," "std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > > > >" "," "std::less< sword::SWBuf >" "," "std::allocator< std::pair< sword::SWBuf const,std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > > > > > >" " >";
	  }
	};
      }
    
SWIGINTERN swig::SwigPyIterator *std_map_Sl_sword_SWBuf_Sc_AttributeListMap_Sg__iterator(std::map< sword::SWBuf,AttributeListMap > *self,PyObject **PYTHON_SELF){
      return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
    }
SWIGINTERN bool std_map_Sl_sword_SWBuf_Sc_AttributeListMap_Sg____nonzero__(std::map< sword::SWBuf,AttributeListMap > const *self){
      return !(self->empty());
    }
SWIGINTERN bool std_map_Sl_sword_SWBuf_Sc_AttributeListMap_Sg____bool__(std::map< sword::SWBuf,AttributeListMap > const *self){
      return !(self->empty());
    }
SWIGINTERN std::map< sword::SWBuf,std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > > > > >::size_type std_map_Sl_sword_SWBuf_Sc_AttributeListMap_Sg____len__(std::map< sword::SWBuf,AttributeListMap > const *self){
      return self->size();
    }
SWIGINTERN std::map< sword::SWBuf,std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > > > > >::mapped_type const &std_map_Sl_sword_SWBuf_Sc_AttributeListMap_Sg____getitem__(std::map< sword::SWBuf,AttributeListMap > *self,std::map< sword::SWBuf,std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > > > > >::key_type const &key){
      std::map< sword::SWBuf,std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > > > >,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > > > > > > >::const_iterator i = self->find(key);
      if (i != self->end())
	return i->second;
      else
	throw std::out_of_range("key not found");
    }
SWIGINTERN void std_map_Sl_sword_SWBuf_Sc_AttributeListMap_Sg____delitem__(std::map< sword::SWBuf,AttributeListMap > *self,std::map< sword::SWBuf,std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > > > > >::key_type const &key){
      std::map< sword::SWBuf,std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > > > >,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > > > > > > >::iterator i = self->find(key);
      if (i != self->end())
	self->erase(i);
      else
	throw std::out_of_range("key not found");
    }
SWIGINTERN bool std_map_Sl_sword_SWBuf_Sc_AttributeListMap_Sg__has_key(std::map< sword::SWBuf,AttributeListMap > const *self,std::map< sword::SWBuf,std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > > > > >::key_type const &key){
      std::map< sword::SWBuf,std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > > > >,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > > > > > > >::const_iterator i = self->find(key);
      return i != self->end();
    }
SWIGINTERN PyObject *std_map_Sl_sword_SWBuf_Sc_AttributeListMap_Sg__keys(std::map< sword::SWBuf,AttributeListMap > *self){
      std::map< sword::SWBuf,std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > > > >,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > > > > > > >::size_type size = self->size();
      Py_ssize_t pysize = (size <= (std::map< sword::SWBuf,std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > > > >,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > > > > > > >::size_type)PY_SSIZE_T_MAX) ? (Py_ssize_t)size : -1;
      SWIG_PYTHON_THREAD_BEGIN_BLOCK;
      if (pysize < 0) {
	PyErr_SetString(PyExc_OverflowError, "map size not valid in python");
	SWIG_PYTHON_THREAD_END_BLOCK;
	return NULL;
      }
      PyObject* keyList = PyList_New(pysize);
      std::map< sword::SWBuf,std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > > > >,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > > > > > > >::const_iterator i = self->begin();
      for (Py_ssize_t j = 0; j < pysize; ++i, ++j) {
	PyList_SET_ITEM(keyList, j, swig::from(i->first));
      }
      SWIG_PYTHON_THREAD_END_BLOCK;
      return keyList;
    }
SWIGINTERN PyObject *std_map_Sl_sword_SWBuf_Sc_AttributeListMap_Sg__values(std::map< sword::SWBuf,AttributeListMap > *self){
      std::map< sword::SWBuf,std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > > > >,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > > > > > > >::size_type size = self->size();
      Py_ssize_t pysize = (size <= (std::map< sword::SWBuf,std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > > > >,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > > > > > > >::size_type)PY_SSIZE_T_MAX) ? (Py_ssize_t)size : -1;
      SWIG_PYTHON_THREAD_BEGIN_BLOCK;
      if (pysize < 0) {
	PyErr_SetString(PyExc_OverflowError, "map size not valid in python");
	SWIG_PYTHON_THREAD_END_BLOCK;
	return NULL;
      }
      PyObject* valList = PyList_New(pysize);
      std::map< sword::SWBuf,std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > > > >,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > > > > > > >::const_iterator i = self->begin();
      for (Py_ssize_t j = 0; j < pysize; ++i, ++j) {
	PyList_SET_ITEM(valList, j, swig::from(i->second));
      }
      SWIG_PYTHON_THREAD_END_BLOCK;
      return valList;
    }
SWIGINTERN PyObject *std_map_Sl_sword_SWBuf_Sc_AttributeListMap_Sg__items(std::map< sword::SWBuf,AttributeListMap > *self){
      std::map< sword::SWBuf,std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > > > >,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > > > > > > >::size_type size = self->size();
      Py_ssize_t pysize = (size <= (std::map< sword::SWBuf,std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > > > >,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > > > > > > >::size_type)PY_SSIZE_T_MAX) ? (Py_ssize_t)size : -1;
      SWIG_PYTHON_THREAD_BEGIN_BLOCK;
      if (pysize < 0) {
	PyErr_SetString(PyExc_OverflowError, "map size not valid in python");
	SWIG_PYTHON_THREAD_END_BLOCK;
	return NULL;
      }    
      PyObject* itemList = PyList_New(pysize);
      std::map< sword::SWBuf,std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > > > >,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > > > > > > >::const_iterator i = self->begin();
      for (Py_ssize_t j = 0; j < pysize; ++i, ++j) {
	PyList_SET_ITEM(itemList, j, swig::from(*i));
      }
      SWIG_PYTHON_THREAD_END_BLOCK;
      return itemList;
    }
SWIGINTERN bool std_map_Sl_sword_SWBuf_Sc_AttributeListMap_Sg____contains__(std::map< sword::SWBuf,AttributeListMap > *self,std::map< sword::SWBuf,std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > > > > >::key_type const &key){
      return self->find(key) != self->end();
    }
SWIGINTERN swig::SwigPyIterator *std_map_Sl_sword_SWBuf_Sc_AttributeListMap_Sg__key_iterator(std::map< sword::SWBuf,AttributeListMap > *self,PyObject **PYTHON_SELF){
      return swig::make_output_key_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
    }
SWIGINTERN swig::SwigPyIterator *std_map_Sl_sword_SWBuf_Sc_AttributeListMap_Sg__value_iterator(std::map< sword::SWBuf,AttributeListMap > *self,PyObject **PYTHON_SELF){
      return swig::make_output_value_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
    }
SWIGINTERN void std_map_Sl_sword_SWBuf_Sc_AttributeListMap_Sg____setitem____SWIG_0(std::map< sword::SWBuf,AttributeListMap > *self,std::map< sword::SWBuf,std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > > > > >::key_type const &key){
      self->erase(key);
    }
SWIGINTERN void std_map_Sl_sword_SWBuf_Sc_AttributeListMap_Sg____setitem____SWIG_1(std::map< sword::SWBuf,AttributeListMap > *self,std::map< sword::SWBuf,std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > > > > >::key_type const &key,std::map< sword::SWBuf,std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > > > > >::mapped_type const &x){
#ifdef __cpp_lib_map_try_emplace
      (*self).insert_or_assign(key, x);
#else
      (*self)[key] = x;
#endif
    }
SWIGINTERN PyObject *std_map_Sl_sword_SWBuf_Sc_AttributeListMap_Sg__asdict(std::map< sword::SWBuf,AttributeListMap > *self){
      return swig::traits_from< std::map< sword::SWBuf,std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > > > >,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > > > > > > > >::asdict(*self);
    }
SWIGINTERN void std_map_Sl_sword_SWBuf_Sc_AttributeListMap_Sg__erase__SWIG_1(std::map< sword::SWBuf,AttributeListMap > *self,std::map< sword::SWBuf,std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > > > > >::iterator position){ self->erase(position); }
SWIGINTERN void std_map_Sl_sword_SWBuf_Sc_AttributeListMap_Sg__erase__SWIG_2(std::map< sword::SWBuf,AttributeListMap > *self,std::map< sword::SWBuf,std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > > > > >::iterator first,std::map< sword::SWBuf,std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > > > > >::iterator last){ self->erase(first, last); }

  namespace swig {
    template <class K, class T>
    struct traits_asptr<std::multimap<K,T> >  {
      typedef std::multimap<K,T> multimap_type;
      static int asptr(PyObject *obj, std::multimap<K,T> **val) {
	int res = SWIG_ERROR;
	if (PyDict_Check(obj)) {
	  SwigVar_PyObject items = PyObject_CallMethod(obj,(char *)"items",NULL);
#if PY_VERSION_HEX >= 0x03000000
          /* In Python 3.x the ".items()" method returns a dict_items object */
          items = PySequence_Fast(items, ".items() didn't return a sequence!");
#endif
	  res = traits_asptr_stdseq<std::multimap<K,T>, std::pair<K, T> >::asptr(items, val);
	} else {
	  multimap_type *p = 0;
	  swig_type_info *descriptor = swig::type_info<multimap_type>();
	  res = descriptor ? SWIG_ConvertPtr(obj, (void **)&p, descriptor, 0) : SWIG_ERROR;
	  if (SWIG_IsOK(res) && val)  *val = p;
	}
	return res;
      }
    };
      
    template <class K, class T >
    struct traits_from<std::multimap<K,T> >  {
      typedef std::multimap<K,T> multimap_type;
      typedef typename multimap_type::const_iterator const_iterator;
      typedef typename multimap_type::size_type size_type;
            
      static PyObject *from(const multimap_type& multimap) {
	swig_type_info *desc = swig::type_info<multimap_type>();
	if (desc && desc->clientdata) {
	  return SWIG_InternalNewPointerObj(new multimap_type(multimap), desc, SWIG_POINTER_OWN);
	} else {
	  size_type size = multimap.size();
	  Py_ssize_t pysize = (size <= (size_type)PY_SSIZE_T_MAX) ? (Py_ssize_t)size : -1;
	  if (pysize < 0) {
	    SWIG_PYTHON_THREAD_BEGIN_BLOCK;
	    PyErr_SetString(PyExc_OverflowError, "multimap size not valid in python");
	    SWIG_PYTHON_THREAD_END_BLOCK;
	    return NULL;
	  }
	  PyObject *obj = PyDict_New();
	  for (const_iterator i= multimap.begin(); i!= multimap.end(); ++i) {
	    swig::SwigVar_PyObject key = swig::from(i->first);
	    swig::SwigVar_PyObject val = swig::from(i->second);
	    PyDict_SetItem(obj, key, val);
	  }
	  return obj;
	}
      }
    };
  }


      namespace swig {
	template <>  struct traits<std::multimap< sword::SWBuf, sword::SWBuf, std::less< sword::SWBuf >, std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::multimap<" "sword::SWBuf" "," "sword::SWBuf" "," "std::less< sword::SWBuf >" "," "std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > >" " >";
	  }
	};
      }
    
SWIGINTERN swig::SwigPyIterator *std_multimap_Sl_sword_SWBuf_Sc_sword_SWBuf_Sc_std_less_Sl_sword_SWBuf_Sg__Sg__iterator(std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > *self,PyObject **PYTHON_SELF){
      return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
    }
SWIGINTERN bool std_multimap_Sl_sword_SWBuf_Sc_sword_SWBuf_Sc_std_less_Sl_sword_SWBuf_Sg__Sg____nonzero__(std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > const *self){
      return !(self->empty());
    }
SWIGINTERN bool std_multimap_Sl_sword_SWBuf_Sc_sword_SWBuf_Sc_std_less_Sl_sword_SWBuf_Sg__Sg____bool__(std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > const *self){
      return !(self->empty());
    }
SWIGINTERN std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > >::size_type std_multimap_Sl_sword_SWBuf_Sc_sword_SWBuf_Sc_std_less_Sl_sword_SWBuf_Sg__Sg____len__(std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > const *self){
      return self->size();
    }
SWIGINTERN std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > >::mapped_type const &std_multimap_Sl_sword_SWBuf_Sc_sword_SWBuf_Sc_std_less_Sl_sword_SWBuf_Sg__Sg____getitem__(std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > *self,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > >::key_type const &key){
      std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >::const_iterator i = self->find(key);
      if (i != self->end())
	return i->second;
      else
	throw std::out_of_range("key not found");
    }
SWIGINTERN void std_multimap_Sl_sword_SWBuf_Sc_sword_SWBuf_Sc_std_less_Sl_sword_SWBuf_Sg__Sg____delitem__(std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > *self,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > >::key_type const &key){
      std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >::iterator i = self->find(key);
      if (i != self->end())
	self->erase(i);
      else
	throw std::out_of_range("key not found");
    }
SWIGINTERN bool std_multimap_Sl_sword_SWBuf_Sc_sword_SWBuf_Sc_std_less_Sl_sword_SWBuf_Sg__Sg__has_key(std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > const *self,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > >::key_type const &key){
      std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >::const_iterator i = self->find(key);
      return i != self->end();
    }
SWIGINTERN PyObject *std_multimap_Sl_sword_SWBuf_Sc_sword_SWBuf_Sc_std_less_Sl_sword_SWBuf_Sg__Sg__keys(std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > *self){
      std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >::size_type size = self->size();
      Py_ssize_t pysize = (size <= (std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >::size_type)PY_SSIZE_T_MAX) ? (Py_ssize_t)size : -1;
      SWIG_PYTHON_THREAD_BEGIN_BLOCK;
      if (pysize < 0) {
	PyErr_SetString(PyExc_OverflowError, "map size not valid in python");
	SWIG_PYTHON_THREAD_END_BLOCK;
	return NULL;
      }
      PyObject* keyList = PyList_New(pysize);
      std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >::const_iterator i = self->begin();
      for (Py_ssize_t j = 0; j < pysize; ++i, ++j) {
	PyList_SET_ITEM(keyList, j, swig::from(i->first));
      }
      SWIG_PYTHON_THREAD_END_BLOCK;
      return keyList;
    }
SWIGINTERN PyObject *std_multimap_Sl_sword_SWBuf_Sc_sword_SWBuf_Sc_std_less_Sl_sword_SWBuf_Sg__Sg__values(std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > *self){
      std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >::size_type size = self->size();
      Py_ssize_t pysize = (size <= (std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >::size_type)PY_SSIZE_T_MAX) ? (Py_ssize_t)size : -1;
      SWIG_PYTHON_THREAD_BEGIN_BLOCK;
      if (pysize < 0) {
	PyErr_SetString(PyExc_OverflowError, "map size not valid in python");
	SWIG_PYTHON_THREAD_END_BLOCK;
	return NULL;
      }
      PyObject* valList = PyList_New(pysize);
      std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >::const_iterator i = self->begin();
      for (Py_ssize_t j = 0; j < pysize; ++i, ++j) {
	PyList_SET_ITEM(valList, j, swig::from(i->second));
      }
      SWIG_PYTHON_THREAD_END_BLOCK;
      return valList;
    }
SWIGINTERN PyObject *std_multimap_Sl_sword_SWBuf_Sc_sword_SWBuf_Sc_std_less_Sl_sword_SWBuf_Sg__Sg__items(std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > *self){
      std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >::size_type size = self->size();
      Py_ssize_t pysize = (size <= (std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >::size_type)PY_SSIZE_T_MAX) ? (Py_ssize_t)size : -1;
      SWIG_PYTHON_THREAD_BEGIN_BLOCK;
      if (pysize < 0) {
	PyErr_SetString(PyExc_OverflowError, "map size not valid in python");
	SWIG_PYTHON_THREAD_END_BLOCK;
	return NULL;
      }    
      PyObject* itemList = PyList_New(pysize);
      std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >::const_iterator i = self->begin();
      for (Py_ssize_t j = 0; j < pysize; ++i, ++j) {
	PyList_SET_ITEM(itemList, j, swig::from(*i));
      }
      SWIG_PYTHON_THREAD_END_BLOCK;
      return itemList;
    }
SWIGINTERN bool std_multimap_Sl_sword_SWBuf_Sc_sword_SWBuf_Sc_std_less_Sl_sword_SWBuf_Sg__Sg____contains__(std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > *self,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > >::key_type const &key){
      return self->find(key) != self->end();
    }
SWIGINTERN swig::SwigPyIterator *std_multimap_Sl_sword_SWBuf_Sc_sword_SWBuf_Sc_std_less_Sl_sword_SWBuf_Sg__Sg__key_iterator(std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > *self,PyObject **PYTHON_SELF){
      return swig::make_output_key_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
    }
SWIGINTERN swig::SwigPyIterator *std_multimap_Sl_sword_SWBuf_Sc_sword_SWBuf_Sc_std_less_Sl_sword_SWBuf_Sg__Sg__value_iterator(std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > *self,PyObject **PYTHON_SELF){
      return swig::make_output_value_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
    }
SWIGINTERN void std_multimap_Sl_sword_SWBuf_Sc_sword_SWBuf_Sc_std_less_Sl_sword_SWBuf_Sg__Sg____setitem____SWIG_0(std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > *self,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > >::key_type const &key){
      self->erase(key);
    }
SWIGINTERN void std_multimap_Sl_sword_SWBuf_Sc_sword_SWBuf_Sc_std_less_Sl_sword_SWBuf_Sg__Sg____setitem____SWIG_1(std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > *self,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > >::key_type const &key,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > >::mapped_type const &x){
      self->insert(std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >::value_type(key,x));
    }
SWIGINTERN void std_multimap_Sl_sword_SWBuf_Sc_sword_SWBuf_Sc_std_less_Sl_sword_SWBuf_Sg__Sg__erase__SWIG_1(std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > *self,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > >::iterator position){ self->erase(position); }
SWIGINTERN void std_multimap_Sl_sword_SWBuf_Sc_sword_SWBuf_Sc_std_less_Sl_sword_SWBuf_Sg__Sg__erase__SWIG_2(std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > *self,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > >::iterator first,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > >::iterator last){ self->erase(first, last); }

      namespace swig {
	template <>  struct traits<std::pair< sword::SWBuf, std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::pair<" "sword::SWBuf" "," "std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >" " >";
	  }
	};
      }
    

      namespace swig {
	template <>  struct traits<std::map< sword::SWBuf, std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >, std::less< sword::SWBuf >, std::allocator< std::pair< sword::SWBuf const,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > > > > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::map<" "sword::SWBuf" "," "std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >" "," "std::less< sword::SWBuf >" "," "std::allocator< std::pair< sword::SWBuf const,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > > >" " >";
	  }
	};
      }
    
SWIGINTERN swig::SwigPyIterator *std_map_Sl_sword_SWBuf_Sc_std_multimap_Sl_sword_SWBuf_Sc_sword_SWBuf_Sc_std_less_Sl_sword_SWBuf_Sg__Sg__Sg__iterator(std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > > *self,PyObject **PYTHON_SELF){
      return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
    }
SWIGINTERN bool std_map_Sl_sword_SWBuf_Sc_std_multimap_Sl_sword_SWBuf_Sc_sword_SWBuf_Sc_std_less_Sl_sword_SWBuf_Sg__Sg__Sg____nonzero__(std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > > const *self){
      return !(self->empty());
    }
SWIGINTERN bool std_map_Sl_sword_SWBuf_Sc_std_multimap_Sl_sword_SWBuf_Sc_sword_SWBuf_Sc_std_less_Sl_sword_SWBuf_Sg__Sg__Sg____bool__(std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > > const *self){
      return !(self->empty());
    }
SWIGINTERN std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > >::size_type std_map_Sl_sword_SWBuf_Sc_std_multimap_Sl_sword_SWBuf_Sc_sword_SWBuf_Sc_std_less_Sl_sword_SWBuf_Sg__Sg__Sg____len__(std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > > const *self){
      return self->size();
    }
SWIGINTERN std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > >::mapped_type const &std_map_Sl_sword_SWBuf_Sc_std_multimap_Sl_sword_SWBuf_Sc_sword_SWBuf_Sc_std_less_Sl_sword_SWBuf_Sg__Sg__Sg____getitem__(std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > > *self,std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > >::key_type const &key){
      std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > > > >::const_iterator i = self->find(key);
      if (i != self->end())
	return i->second;
      else
	throw std::out_of_range("key not found");
    }
SWIGINTERN void std_map_Sl_sword_SWBuf_Sc_std_multimap_Sl_sword_SWBuf_Sc_sword_SWBuf_Sc_std_less_Sl_sword_SWBuf_Sg__Sg__Sg____delitem__(std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > > *self,std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > >::key_type const &key){
      std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > > > >::iterator i = self->find(key);
      if (i != self->end())
	self->erase(i);
      else
	throw std::out_of_range("key not found");
    }
SWIGINTERN bool std_map_Sl_sword_SWBuf_Sc_std_multimap_Sl_sword_SWBuf_Sc_sword_SWBuf_Sc_std_less_Sl_sword_SWBuf_Sg__Sg__Sg__has_key(std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > > const *self,std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > >::key_type const &key){
      std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > > > >::const_iterator i = self->find(key);
      return i != self->end();
    }
SWIGINTERN PyObject *std_map_Sl_sword_SWBuf_Sc_std_multimap_Sl_sword_SWBuf_Sc_sword_SWBuf_Sc_std_less_Sl_sword_SWBuf_Sg__Sg__Sg__keys(std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > > *self){
      std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > > > >::size_type size = self->size();
      Py_ssize_t pysize = (size <= (std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > > > >::size_type)PY_SSIZE_T_MAX) ? (Py_ssize_t)size : -1;
      SWIG_PYTHON_THREAD_BEGIN_BLOCK;
      if (pysize < 0) {
	PyErr_SetString(PyExc_OverflowError, "map size not valid in python");
	SWIG_PYTHON_THREAD_END_BLOCK;
	return NULL;
      }
      PyObject* keyList = PyList_New(pysize);
      std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > > > >::const_iterator i = self->begin();
      for (Py_ssize_t j = 0; j < pysize; ++i, ++j) {
	PyList_SET_ITEM(keyList, j, swig::from(i->first));
      }
      SWIG_PYTHON_THREAD_END_BLOCK;
      return keyList;
    }
SWIGINTERN PyObject *std_map_Sl_sword_SWBuf_Sc_std_multimap_Sl_sword_SWBuf_Sc_sword_SWBuf_Sc_std_less_Sl_sword_SWBuf_Sg__Sg__Sg__values(std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > > *self){
      std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > > > >::size_type size = self->size();
      Py_ssize_t pysize = (size <= (std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > > > >::size_type)PY_SSIZE_T_MAX) ? (Py_ssize_t)size : -1;
      SWIG_PYTHON_THREAD_BEGIN_BLOCK;
      if (pysize < 0) {
	PyErr_SetString(PyExc_OverflowError, "map size not valid in python");
	SWIG_PYTHON_THREAD_END_BLOCK;
	return NULL;
      }
      PyObject* valList = PyList_New(pysize);
      std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > > > >::const_iterator i = self->begin();
      for (Py_ssize_t j = 0; j < pysize; ++i, ++j) {
	PyList_SET_ITEM(valList, j, swig::from(i->second));
      }
      SWIG_PYTHON_THREAD_END_BLOCK;
      return valList;
    }
SWIGINTERN PyObject *std_map_Sl_sword_SWBuf_Sc_std_multimap_Sl_sword_SWBuf_Sc_sword_SWBuf_Sc_std_less_Sl_sword_SWBuf_Sg__Sg__Sg__items(std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > > *self){
      std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > > > >::size_type size = self->size();
      Py_ssize_t pysize = (size <= (std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > > > >::size_type)PY_SSIZE_T_MAX) ? (Py_ssize_t)size : -1;
      SWIG_PYTHON_THREAD_BEGIN_BLOCK;
      if (pysize < 0) {
	PyErr_SetString(PyExc_OverflowError, "map size not valid in python");
	SWIG_PYTHON_THREAD_END_BLOCK;
	return NULL;
      }    
      PyObject* itemList = PyList_New(pysize);
      std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > > > >::const_iterator i = self->begin();
      for (Py_ssize_t j = 0; j < pysize; ++i, ++j) {
	PyList_SET_ITEM(itemList, j, swig::from(*i));
      }
      SWIG_PYTHON_THREAD_END_BLOCK;
      return itemList;
    }
SWIGINTERN bool std_map_Sl_sword_SWBuf_Sc_std_multimap_Sl_sword_SWBuf_Sc_sword_SWBuf_Sc_std_less_Sl_sword_SWBuf_Sg__Sg__Sg____contains__(std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > > *self,std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > >::key_type const &key){
      return self->find(key) != self->end();
    }
SWIGINTERN swig::SwigPyIterator *std_map_Sl_sword_SWBuf_Sc_std_multimap_Sl_sword_SWBuf_Sc_sword_SWBuf_Sc_std_less_Sl_sword_SWBuf_Sg__Sg__Sg__key_iterator(std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > > *self,PyObject **PYTHON_SELF){
      return swig::make_output_key_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
    }
SWIGINTERN swig::SwigPyIterator *std_map_Sl_sword_SWBuf_Sc_std_multimap_Sl_sword_SWBuf_Sc_sword_SWBuf_Sc_std_less_Sl_sword_SWBuf_Sg__Sg__Sg__value_iterator(std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > > *self,PyObject **PYTHON_SELF){
      return swig::make_output_value_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
    }
SWIGINTERN void std_map_Sl_sword_SWBuf_Sc_std_multimap_Sl_sword_SWBuf_Sc_sword_SWBuf_Sc_std_less_Sl_sword_SWBuf_Sg__Sg__Sg____setitem____SWIG_0(std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > > *self,std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > >::key_type const &key){
      self->erase(key);
    }
SWIGINTERN void std_map_Sl_sword_SWBuf_Sc_std_multimap_Sl_sword_SWBuf_Sc_sword_SWBuf_Sc_std_less_Sl_sword_SWBuf_Sg__Sg__Sg____setitem____SWIG_1(std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > > *self,std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > >::key_type const &key,std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > >::mapped_type const &x){
#ifdef __cpp_lib_map_try_emplace
      (*self).insert_or_assign(key, x);
#else
      (*self)[key] = x;
#endif
    }
SWIGINTERN PyObject *std_map_Sl_sword_SWBuf_Sc_std_multimap_Sl_sword_SWBuf_Sc_sword_SWBuf_Sc_std_less_Sl_sword_SWBuf_Sg__Sg__Sg__asdict(std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > > *self){
      return swig::traits_from< std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > > > > >::asdict(*self);
    }
SWIGINTERN void std_map_Sl_sword_SWBuf_Sc_std_multimap_Sl_sword_SWBuf_Sc_sword_SWBuf_Sc_std_less_Sl_sword_SWBuf_Sg__Sg__Sg__erase__SWIG_1(std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > > *self,std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > >::iterator position){ self->erase(position); }
SWIGINTERN void std_map_Sl_sword_SWBuf_Sc_std_multimap_Sl_sword_SWBuf_Sc_sword_SWBuf_Sc_std_less_Sl_sword_SWBuf_Sg__Sg__Sg__erase__SWIG_2(std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > > *self,std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > >::iterator first,std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > >::iterator last){ self->erase(first, last); }

  namespace swig {
    template <>  struct traits< sword::SWModule > {
      typedef pointer_category category;
      static const char* type_name() { return"sword::SWModule"; }
    };
  }


      namespace swig {
	template <>  struct traits<std::pair< sword::SWBuf, sword::SWModule* > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::pair<" "sword::SWBuf" "," "sword::SWModule" " * >";
	  }
	};
      }
    

      namespace swig {
	template <>  struct traits<std::map< sword::SWBuf, sword::SWModule *, std::less< sword::SWBuf >, std::allocator< std::pair< sword::SWBuf const,sword::SWModule * > > > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::map<" "sword::SWBuf" "," "sword::SWModule *" "," "std::less< sword::SWBuf >" "," "std::allocator< std::pair< sword::SWBuf const,sword::SWModule * > >" " >";
	  }
	};
      }
    
SWIGINTERN swig::SwigPyIterator *std_map_Sl_sword_SWBuf_Sc_sword_SWModule_Sm__Sg__iterator(std::map< sword::SWBuf,sword::SWModule * > *self,PyObject **PYTHON_SELF){
      return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
    }
SWIGINTERN bool std_map_Sl_sword_SWBuf_Sc_sword_SWModule_Sm__Sg____nonzero__(std::map< sword::SWBuf,sword::SWModule * > const *self){
      return !(self->empty());
    }
SWIGINTERN bool std_map_Sl_sword_SWBuf_Sc_sword_SWModule_Sm__Sg____bool__(std::map< sword::SWBuf,sword::SWModule * > const *self){
      return !(self->empty());
    }
SWIGINTERN std::map< sword::SWBuf,sword::SWModule * >::size_type std_map_Sl_sword_SWBuf_Sc_sword_SWModule_Sm__Sg____len__(std::map< sword::SWBuf,sword::SWModule * > const *self){
      return self->size();
    }
SWIGINTERN std::map< sword::SWBuf,sword::SWModule * >::mapped_type const &std_map_Sl_sword_SWBuf_Sc_sword_SWModule_Sm__Sg____getitem__(std::map< sword::SWBuf,sword::SWModule * > *self,std::map< sword::SWBuf,sword::SWModule * >::key_type const &key){
      std::map< sword::SWBuf,sword::SWModule *,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWModule * > > >::const_iterator i = self->find(key);
      if (i != self->end())
	return i->second;
      else
	throw std::out_of_range("key not found");
    }
SWIGINTERN void std_map_Sl_sword_SWBuf_Sc_sword_SWModule_Sm__Sg____delitem__(std::map< sword::SWBuf,sword::SWModule * > *self,std::map< sword::SWBuf,sword::SWModule * >::key_type const &key){
      std::map< sword::SWBuf,sword::SWModule *,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWModule * > > >::iterator i = self->find(key);
      if (i != self->end())
	self->erase(i);
      else
	throw std::out_of_range("key not found");
    }
SWIGINTERN bool std_map_Sl_sword_SWBuf_Sc_sword_SWModule_Sm__Sg__has_key(std::map< sword::SWBuf,sword::SWModule * > const *self,std::map< sword::SWBuf,sword::SWModule * >::key_type const &key){
      std::map< sword::SWBuf,sword::SWModule *,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWModule * > > >::const_iterator i = self->find(key);
      return i != self->end();
    }
SWIGINTERN PyObject *std_map_Sl_sword_SWBuf_Sc_sword_SWModule_Sm__Sg__keys(std::map< sword::SWBuf,sword::SWModule * > *self){
      std::map< sword::SWBuf,sword::SWModule *,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWModule * > > >::size_type size = self->size();
      Py_ssize_t pysize = (size <= (std::map< sword::SWBuf,sword::SWModule *,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWModule * > > >::size_type)PY_SSIZE_T_MAX) ? (Py_ssize_t)size : -1;
      SWIG_PYTHON_THREAD_BEGIN_BLOCK;
      if (pysize < 0) {
	PyErr_SetString(PyExc_OverflowError, "map size not valid in python");
	SWIG_PYTHON_THREAD_END_BLOCK;
	return NULL;
      }
      PyObject* keyList = PyList_New(pysize);
      std::map< sword::SWBuf,sword::SWModule *,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWModule * > > >::const_iterator i = self->begin();
      for (Py_ssize_t j = 0; j < pysize; ++i, ++j) {
	PyList_SET_ITEM(keyList, j, swig::from(i->first));
      }
      SWIG_PYTHON_THREAD_END_BLOCK;
      return keyList;
    }
SWIGINTERN PyObject *std_map_Sl_sword_SWBuf_Sc_sword_SWModule_Sm__Sg__values(std::map< sword::SWBuf,sword::SWModule * > *self){
      std::map< sword::SWBuf,sword::SWModule *,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWModule * > > >::size_type size = self->size();
      Py_ssize_t pysize = (size <= (std::map< sword::SWBuf,sword::SWModule *,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWModule * > > >::size_type)PY_SSIZE_T_MAX) ? (Py_ssize_t)size : -1;
      SWIG_PYTHON_THREAD_BEGIN_BLOCK;
      if (pysize < 0) {
	PyErr_SetString(PyExc_OverflowError, "map size not valid in python");
	SWIG_PYTHON_THREAD_END_BLOCK;
	return NULL;
      }
      PyObject* valList = PyList_New(pysize);
      std::map< sword::SWBuf,sword::SWModule *,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWModule * > > >::const_iterator i = self->begin();
      for (Py_ssize_t j = 0; j < pysize; ++i, ++j) {
	PyList_SET_ITEM(valList, j, swig::from(i->second));
      }
      SWIG_PYTHON_THREAD_END_BLOCK;
      return valList;
    }
SWIGINTERN PyObject *std_map_Sl_sword_SWBuf_Sc_sword_SWModule_Sm__Sg__items(std::map< sword::SWBuf,sword::SWModule * > *self){
      std::map< sword::SWBuf,sword::SWModule *,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWModule * > > >::size_type size = self->size();
      Py_ssize_t pysize = (size <= (std::map< sword::SWBuf,sword::SWModule *,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWModule * > > >::size_type)PY_SSIZE_T_MAX) ? (Py_ssize_t)size : -1;
      SWIG_PYTHON_THREAD_BEGIN_BLOCK;
      if (pysize < 0) {
	PyErr_SetString(PyExc_OverflowError, "map size not valid in python");
	SWIG_PYTHON_THREAD_END_BLOCK;
	return NULL;
      }    
      PyObject* itemList = PyList_New(pysize);
      std::map< sword::SWBuf,sword::SWModule *,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWModule * > > >::const_iterator i = self->begin();
      for (Py_ssize_t j = 0; j < pysize; ++i, ++j) {
	PyList_SET_ITEM(itemList, j, swig::from(*i));
      }
      SWIG_PYTHON_THREAD_END_BLOCK;
      return itemList;
    }
SWIGINTERN bool std_map_Sl_sword_SWBuf_Sc_sword_SWModule_Sm__Sg____contains__(std::map< sword::SWBuf,sword::SWModule * > *self,std::map< sword::SWBuf,sword::SWModule * >::key_type const &key){
      return self->find(key) != self->end();
    }
SWIGINTERN swig::SwigPyIterator *std_map_Sl_sword_SWBuf_Sc_sword_SWModule_Sm__Sg__key_iterator(std::map< sword::SWBuf,sword::SWModule * > *self,PyObject **PYTHON_SELF){
      return swig::make_output_key_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
    }
SWIGINTERN swig::SwigPyIterator *std_map_Sl_sword_SWBuf_Sc_sword_SWModule_Sm__Sg__value_iterator(std::map< sword::SWBuf,sword::SWModule * > *self,PyObject **PYTHON_SELF){
      return swig::make_output_value_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
    }
SWIGINTERN void std_map_Sl_sword_SWBuf_Sc_sword_SWModule_Sm__Sg____setitem____SWIG_0(std::map< sword::SWBuf,sword::SWModule * > *self,std::map< sword::SWBuf,sword::SWModule * >::key_type const &key){
      self->erase(key);
    }
SWIGINTERN void std_map_Sl_sword_SWBuf_Sc_sword_SWModule_Sm__Sg____setitem____SWIG_1(std::map< sword::SWBuf,sword::SWModule * > *self,std::map< sword::SWBuf,sword::SWModule * >::key_type const &key,std::map< sword::SWBuf,sword::SWModule * >::mapped_type const &x){
#ifdef __cpp_lib_map_try_emplace
      (*self).insert_or_assign(key, x);
#else
      (*self)[key] = x;
#endif
    }
SWIGINTERN PyObject *std_map_Sl_sword_SWBuf_Sc_sword_SWModule_Sm__Sg__asdict(std::map< sword::SWBuf,sword::SWModule * > *self){
      return swig::traits_from< std::map< sword::SWBuf,sword::SWModule *,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWModule * > > > >::asdict(*self);
    }
SWIGINTERN void std_map_Sl_sword_SWBuf_Sc_sword_SWModule_Sm__Sg__erase__SWIG_1(std::map< sword::SWBuf,sword::SWModule * > *self,std::map< sword::SWBuf,sword::SWModule * >::iterator position){ self->erase(position); }
SWIGINTERN void std_map_Sl_sword_SWBuf_Sc_sword_SWModule_Sm__Sg__erase__SWIG_2(std::map< sword::SWBuf,sword::SWModule * > *self,std::map< sword::SWBuf,sword::SWModule * >::iterator first,std::map< sword::SWBuf,sword::SWModule * >::iterator last){ self->erase(first, last); }

  namespace swig {
    template <class T>
    struct traits_reserve<std::vector<T> > {
      static void reserve(std::vector<T> &seq, typename std::vector<T>::size_type n) {
        seq.reserve(n);
      }
    };

    template <class T>
    struct traits_asptr<std::vector<T> >  {
      static int asptr(PyObject *obj, std::vector<T> **vec) {
	return traits_asptr_stdseq<std::vector<T> >::asptr(obj, vec);
      }
    };
    
    template <class T>
    struct traits_from<std::vector<T> > {
      static PyObject *from(const std::vector<T>& vec) {
	return traits_from_stdseq<std::vector<T> >::from(vec);
      }
    };
  }


      namespace swig {
	template <>  struct traits<std::vector< sword::SWBuf, std::allocator< sword::SWBuf > > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::vector<" "sword::SWBuf" "," "std::allocator< sword::SWBuf >" " >";
	  }
	};
      }
    
SWIGINTERN swig::SwigPyIterator *std_vector_Sl_sword_SWBuf_Sg__iterator(std::vector< sword::SWBuf > *self,PyObject **PYTHON_SELF){
      return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
    }
SWIGINTERN bool std_vector_Sl_sword_SWBuf_Sg____nonzero__(std::vector< sword::SWBuf > const *self){
      return !(self->empty());
    }
SWIGINTERN bool std_vector_Sl_sword_SWBuf_Sg____bool__(std::vector< sword::SWBuf > const *self){
      return !(self->empty());
    }
SWIGINTERN std::vector< sword::SWBuf >::size_type std_vector_Sl_sword_SWBuf_Sg____len__(std::vector< sword::SWBuf > const *self){
      return self->size();
    }
SWIGINTERN std::vector< sword::SWBuf,std::allocator< sword::SWBuf > > *std_vector_Sl_sword_SWBuf_Sg____getslice__(std::vector< sword::SWBuf > *self,std::vector< sword::SWBuf >::difference_type i,std::vector< sword::SWBuf >::difference_type j){
      return swig::getslice(self, i, j, 1);
    }
SWIGINTERN void std_vector_Sl_sword_SWBuf_Sg____setslice____SWIG_0(std::vector< sword::SWBuf > *self,std::vector< sword::SWBuf >::difference_type i,std::vector< sword::SWBuf >::difference_type j){
      swig::setslice(self, i, j, 1, std::vector< sword::SWBuf,std::allocator< sword::SWBuf > >());
    }
SWIGINTERN void std_vector_Sl_sword_SWBuf_Sg____setslice____SWIG_1(std::vector< sword::SWBuf > *self,std::vector< sword::SWBuf >::difference_type i,std::vector< sword::SWBuf >::difference_type j,std::vector< sword::SWBuf,std::allocator< sword::SWBuf > > const &v){
      swig::setslice(self, i, j, 1, v);
    }
SWIGINTERN void std_vector_Sl_sword_SWBuf_Sg____delslice__(std::vector< sword::SWBuf > *self,std::vector< sword::SWBuf >::difference_type i,std::vector< sword::SWBuf >::difference_type j){
      swig::delslice(self, i, j, 1);
    }
SWIGINTERN void std_vector_Sl_sword_SWBuf_Sg____delitem____SWIG_0(std::vector< sword::SWBuf > *self,std::vector< sword::SWBuf >::difference_type i){
      swig::erase(self, swig::getpos(self, i));
    }
SWIGINTERN std::vector< sword::SWBuf,std::allocator< sword::SWBuf > > *std_vector_Sl_sword_SWBuf_Sg____getitem____SWIG_0(std::vector< sword::SWBuf > *self,SWIGPY_SLICEOBJECT *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return NULL;
      }
      PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< sword::SWBuf,std::allocator< sword::SWBuf > >::difference_type id = i;
      std::vector< sword::SWBuf,std::allocator< sword::SWBuf > >::difference_type jd = j;
      return swig::getslice(self, id, jd, step);
    }
SWIGINTERN void std_vector_Sl_sword_SWBuf_Sg____setitem____SWIG_0(std::vector< sword::SWBuf > *self,SWIGPY_SLICEOBJECT *slice,std::vector< sword::SWBuf,std::allocator< sword::SWBuf > > const &v){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< sword::SWBuf,std::allocator< sword::SWBuf > >::difference_type id = i;
      std::vector< sword::SWBuf,std::allocator< sword::SWBuf > >::difference_type jd = j;
      swig::setslice(self, id, jd, step, v);
    }
SWIGINTERN void std_vector_Sl_sword_SWBuf_Sg____setitem____SWIG_1(std::vector< sword::SWBuf > *self,SWIGPY_SLICEOBJECT *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< sword::SWBuf,std::allocator< sword::SWBuf > >::difference_type id = i;
      std::vector< sword::SWBuf,std::allocator< sword::SWBuf > >::difference_type jd = j;
      swig::delslice(self, id, jd, step);
    }
SWIGINTERN void std_vector_Sl_sword_SWBuf_Sg____delitem____SWIG_1(std::vector< sword::SWBuf > *self,SWIGPY_SLICEOBJECT *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< sword::SWBuf,std::allocator< sword::SWBuf > >::difference_type id = i;
      std::vector< sword::SWBuf,std::allocator< sword::SWBuf > >::difference_type jd = j;
      swig::delslice(self, id, jd, step);
    }
SWIGINTERN std::vector< sword::SWBuf >::value_type const &std_vector_Sl_sword_SWBuf_Sg____getitem____SWIG_1(std::vector< sword::SWBuf > const *self,std::vector< sword::SWBuf >::difference_type i){
      return *(swig::cgetpos(self, i));
    }

namespace swig {
  static PyObject* container_owner_attribute() {
    static PyObject* attr = SWIG_Python_str_FromChar("__swig_container");
    return attr;
  }

  template <typename T>
  struct container_owner {
    // By default, do not add the back-reference (for value types)
    // Specialization below will check the reference for pointer types.
    static bool back_reference(PyObject* /*child*/, PyObject* /*owner*/) {
      return false;
    }
  };

  template <>
  struct container_owner<swig::pointer_category> {  
    /*
     * Call to add a back-reference to the owning object when returning a 
     * reference from a container.  Will only set the reference if child
     * is a SWIG wrapper object that does not own the pointer.
     *
     * returns whether the reference was set or not
     */
    static bool back_reference(PyObject* child, PyObject* owner) {
      SwigPyObject* swigThis = SWIG_Python_GetSwigThis(child);
      if (swigThis && (swigThis->own & SWIG_POINTER_OWN) != SWIG_POINTER_OWN) {
        return PyObject_SetAttr(child, container_owner_attribute(), owner) != -1;
      }
      return false;
    }
  };
}

SWIGINTERN void std_vector_Sl_sword_SWBuf_Sg____setitem____SWIG_2(std::vector< sword::SWBuf > *self,std::vector< sword::SWBuf >::difference_type i,std::vector< sword::SWBuf >::value_type const &x){
      *(swig::getpos(self,i)) = x;
    }
SWIGINTERN std::vector< sword::SWBuf >::value_type std_vector_Sl_sword_SWBuf_Sg__pop(std::vector< sword::SWBuf > *self){
      if (self->size() == 0)
	throw std::out_of_range("pop from empty container");
      std::vector< sword::SWBuf,std::allocator< sword::SWBuf > >::value_type x = self->back();
      self->pop_back();
      return x;
    }
SWIGINTERN void std_vector_Sl_sword_SWBuf_Sg__append(std::vector< sword::SWBuf > *self,std::vector< sword::SWBuf >::value_type const &x){
      self->push_back(x);
    }
SWIGINTERN std::vector< sword::SWBuf >::iterator std_vector_Sl_sword_SWBuf_Sg__erase__SWIG_0(std::vector< sword::SWBuf > *self,std::vector< sword::SWBuf >::iterator pos){ return self->erase(pos); }
SWIGINTERN std::vector< sword::SWBuf >::iterator std_vector_Sl_sword_SWBuf_Sg__erase__SWIG_1(std::vector< sword::SWBuf > *self,std::vector< sword::SWBuf >::iterator first,std::vector< sword::SWBuf >::iterator last){ return self->erase(first, last); }
SWIGINTERN std::vector< sword::SWBuf >::iterator std_vector_Sl_sword_SWBuf_Sg__insert__SWIG_0(std::vector< sword::SWBuf > *self,std::vector< sword::SWBuf >::iterator pos,std::vector< sword::SWBuf >::value_type const &x){ return self->insert(pos, x); }
SWIGINTERN void std_vector_Sl_sword_SWBuf_Sg__insert__SWIG_1(std::vector< sword::SWBuf > *self,std::vector< sword::SWBuf >::iterator pos,std::vector< sword::SWBuf >::size_type n,std::vector< sword::SWBuf >::value_type const &x){ self->insert(pos, n, x); }

  namespace swig {
    template <class T >
    struct traits_asptr<std::list<T> >  {
      static int asptr(PyObject *obj, std::list<T> **lis) {
	return traits_asptr_stdseq<std::list<T> >::asptr(obj, lis);
      }
    };

    template <class T>
    struct traits_from<std::list<T> > {
      static PyObject *from(const std::list<T>& vec) {
	return traits_from_stdseq<std::list<T> >::from(vec);
      }
    };
  }


      namespace swig {
	template <>  struct traits<std::list< sword::SWBuf, std::allocator< sword::SWBuf > > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::list<" "sword::SWBuf" ", " "std::allocator< sword::SWBuf >" " >";
	  }
	};
      }
    
SWIGINTERN swig::SwigPyIterator *std_list_Sl_sword_SWBuf_Sg__iterator(std::list< sword::SWBuf > *self,PyObject **PYTHON_SELF){
      return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
    }
SWIGINTERN bool std_list_Sl_sword_SWBuf_Sg____nonzero__(std::list< sword::SWBuf > const *self){
      return !(self->empty());
    }
SWIGINTERN bool std_list_Sl_sword_SWBuf_Sg____bool__(std::list< sword::SWBuf > const *self){
      return !(self->empty());
    }
SWIGINTERN std::list< sword::SWBuf >::size_type std_list_Sl_sword_SWBuf_Sg____len__(std::list< sword::SWBuf > const *self){
      return self->size();
    }
SWIGINTERN std::list< sword::SWBuf,std::allocator< sword::SWBuf > > *std_list_Sl_sword_SWBuf_Sg____getslice__(std::list< sword::SWBuf > *self,std::list< sword::SWBuf >::difference_type i,std::list< sword::SWBuf >::difference_type j){
      return swig::getslice(self, i, j, 1);
    }
SWIGINTERN void std_list_Sl_sword_SWBuf_Sg____setslice____SWIG_0(std::list< sword::SWBuf > *self,std::list< sword::SWBuf >::difference_type i,std::list< sword::SWBuf >::difference_type j){
      swig::setslice(self, i, j, 1, std::list< sword::SWBuf,std::allocator< sword::SWBuf > >());
    }
SWIGINTERN void std_list_Sl_sword_SWBuf_Sg____setslice____SWIG_1(std::list< sword::SWBuf > *self,std::list< sword::SWBuf >::difference_type i,std::list< sword::SWBuf >::difference_type j,std::list< sword::SWBuf,std::allocator< sword::SWBuf > > const &v){
      swig::setslice(self, i, j, 1, v);
    }
SWIGINTERN void std_list_Sl_sword_SWBuf_Sg____delslice__(std::list< sword::SWBuf > *self,std::list< sword::SWBuf >::difference_type i,std::list< sword::SWBuf >::difference_type j){
      swig::delslice(self, i, j, 1);
    }
SWIGINTERN void std_list_Sl_sword_SWBuf_Sg____delitem____SWIG_0(std::list< sword::SWBuf > *self,std::list< sword::SWBuf >::difference_type i){
      swig::erase(self, swig::getpos(self, i));
    }
SWIGINTERN std::list< sword::SWBuf,std::allocator< sword::SWBuf > > *std_list_Sl_sword_SWBuf_Sg____getitem____SWIG_0(std::list< sword::SWBuf > *self,SWIGPY_SLICEOBJECT *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return NULL;
      }
      PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
      std::list< sword::SWBuf,std::allocator< sword::SWBuf > >::difference_type id = i;
      std::list< sword::SWBuf,std::allocator< sword::SWBuf > >::difference_type jd = j;
      return swig::getslice(self, id, jd, step);
    }
SWIGINTERN void std_list_Sl_sword_SWBuf_Sg____setitem____SWIG_0(std::list< sword::SWBuf > *self,SWIGPY_SLICEOBJECT *slice,std::list< sword::SWBuf,std::allocator< sword::SWBuf > > const &v){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
      std::list< sword::SWBuf,std::allocator< sword::SWBuf > >::difference_type id = i;
      std::list< sword::SWBuf,std::allocator< sword::SWBuf > >::difference_type jd = j;
      swig::setslice(self, id, jd, step, v);
    }
SWIGINTERN void std_list_Sl_sword_SWBuf_Sg____setitem____SWIG_1(std::list< sword::SWBuf > *self,SWIGPY_SLICEOBJECT *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
      std::list< sword::SWBuf,std::allocator< sword::SWBuf > >::difference_type id = i;
      std::list< sword::SWBuf,std::allocator< sword::SWBuf > >::difference_type jd = j;
      swig::delslice(self, id, jd, step);
    }
SWIGINTERN void std_list_Sl_sword_SWBuf_Sg____delitem____SWIG_1(std::list< sword::SWBuf > *self,SWIGPY_SLICEOBJECT *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
      std::list< sword::SWBuf,std::allocator< sword::SWBuf > >::difference_type id = i;
      std::list< sword::SWBuf,std::allocator< sword::SWBuf > >::difference_type jd = j;
      swig::delslice(self, id, jd, step);
    }
SWIGINTERN std::list< sword::SWBuf >::value_type const &std_list_Sl_sword_SWBuf_Sg____getitem____SWIG_1(std::list< sword::SWBuf > const *self,std::list< sword::SWBuf >::difference_type i){
      return *(swig::cgetpos(self, i));
    }
SWIGINTERN void std_list_Sl_sword_SWBuf_Sg____setitem____SWIG_2(std::list< sword::SWBuf > *self,std::list< sword::SWBuf >::difference_type i,std::list< sword::SWBuf >::value_type const &x){
      *(swig::getpos(self,i)) = x;
    }
SWIGINTERN std::list< sword::SWBuf >::value_type std_list_Sl_sword_SWBuf_Sg__pop(std::list< sword::SWBuf > *self){
      if (self->size() == 0)
	throw std::out_of_range("pop from empty container");
      std::list< sword::SWBuf,std::allocator< sword::SWBuf > >::value_type x = self->back();
      self->pop_back();
      return x;
    }
SWIGINTERN void std_list_Sl_sword_SWBuf_Sg__append(std::list< sword::SWBuf > *self,std::list< sword::SWBuf >::value_type const &x){
      self->push_back(x);
    }
SWIGINTERN std::list< sword::SWBuf >::iterator std_list_Sl_sword_SWBuf_Sg__erase__SWIG_0(std::list< sword::SWBuf > *self,std::list< sword::SWBuf >::iterator pos){ return self->erase(pos); }
SWIGINTERN std::list< sword::SWBuf >::iterator std_list_Sl_sword_SWBuf_Sg__erase__SWIG_1(std::list< sword::SWBuf > *self,std::list< sword::SWBuf >::iterator first,std::list< sword::SWBuf >::iterator last){ return self->erase(first, last); }
SWIGINTERN std::list< sword::SWBuf >::iterator std_list_Sl_sword_SWBuf_Sg__insert__SWIG_0(std::list< sword::SWBuf > *self,std::list< sword::SWBuf >::iterator pos,std::list< sword::SWBuf >::value_type const &x){ return self->insert(pos, x); }
SWIGINTERN void std_list_Sl_sword_SWBuf_Sg__insert__SWIG_1(std::list< sword::SWBuf > *self,std::list< sword::SWBuf >::iterator pos,std::list< sword::SWBuf >::size_type n,std::list< sword::SWBuf >::value_type const &x){ self->insert(pos, n, x); }

#include "installmgr.h"


  namespace swig {
    template <>  struct traits< sword::InstallSource > {
      typedef pointer_category category;
      static const char* type_name() { return"sword::InstallSource"; }
    };
  }


      namespace swig {
	template <>  struct traits<std::pair< sword::SWBuf, sword::InstallSource* > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::pair<" "sword::SWBuf" "," "sword::InstallSource" " * >";
	  }
	};
      }
    

      namespace swig {
	template <>  struct traits<std::map< sword::SWBuf, sword::InstallSource *, std::less< sword::SWBuf >, std::allocator< std::pair< sword::SWBuf const,sword::InstallSource * > > > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::map<" "sword::SWBuf" "," "sword::InstallSource *" "," "std::less< sword::SWBuf >" "," "std::allocator< std::pair< sword::SWBuf const,sword::InstallSource * > >" " >";
	  }
	};
      }
    
SWIGINTERN swig::SwigPyIterator *std_map_Sl_sword_SWBuf_Sc_sword_InstallSource_Sm__Sg__iterator(std::map< sword::SWBuf,sword::InstallSource * > *self,PyObject **PYTHON_SELF){
      return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
    }
SWIGINTERN bool std_map_Sl_sword_SWBuf_Sc_sword_InstallSource_Sm__Sg____nonzero__(std::map< sword::SWBuf,sword::InstallSource * > const *self){
      return !(self->empty());
    }
SWIGINTERN bool std_map_Sl_sword_SWBuf_Sc_sword_InstallSource_Sm__Sg____bool__(std::map< sword::SWBuf,sword::InstallSource * > const *self){
      return !(self->empty());
    }
SWIGINTERN std::map< sword::SWBuf,sword::InstallSource * >::size_type std_map_Sl_sword_SWBuf_Sc_sword_InstallSource_Sm__Sg____len__(std::map< sword::SWBuf,sword::InstallSource * > const *self){
      return self->size();
    }
SWIGINTERN std::map< sword::SWBuf,sword::InstallSource * >::mapped_type const &std_map_Sl_sword_SWBuf_Sc_sword_InstallSource_Sm__Sg____getitem__(std::map< sword::SWBuf,sword::InstallSource * > *self,std::map< sword::SWBuf,sword::InstallSource * >::key_type const &key){
      std::map< sword::SWBuf,sword::InstallSource *,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::InstallSource * > > >::const_iterator i = self->find(key);
      if (i != self->end())
	return i->second;
      else
	throw std::out_of_range("key not found");
    }
SWIGINTERN void std_map_Sl_sword_SWBuf_Sc_sword_InstallSource_Sm__Sg____delitem__(std::map< sword::SWBuf,sword::InstallSource * > *self,std::map< sword::SWBuf,sword::InstallSource * >::key_type const &key){
      std::map< sword::SWBuf,sword::InstallSource *,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::InstallSource * > > >::iterator i = self->find(key);
      if (i != self->end())
	self->erase(i);
      else
	throw std::out_of_range("key not found");
    }
SWIGINTERN bool std_map_Sl_sword_SWBuf_Sc_sword_InstallSource_Sm__Sg__has_key(std::map< sword::SWBuf,sword::InstallSource * > const *self,std::map< sword::SWBuf,sword::InstallSource * >::key_type const &key){
      std::map< sword::SWBuf,sword::InstallSource *,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::InstallSource * > > >::const_iterator i = self->find(key);
      return i != self->end();
    }
SWIGINTERN PyObject *std_map_Sl_sword_SWBuf_Sc_sword_InstallSource_Sm__Sg__keys(std::map< sword::SWBuf,sword::InstallSource * > *self){
      std::map< sword::SWBuf,sword::InstallSource *,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::InstallSource * > > >::size_type size = self->size();
      Py_ssize_t pysize = (size <= (std::map< sword::SWBuf,sword::InstallSource *,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::InstallSource * > > >::size_type)PY_SSIZE_T_MAX) ? (Py_ssize_t)size : -1;
      SWIG_PYTHON_THREAD_BEGIN_BLOCK;
      if (pysize < 0) {
	PyErr_SetString(PyExc_OverflowError, "map size not valid in python");
	SWIG_PYTHON_THREAD_END_BLOCK;
	return NULL;
      }
      PyObject* keyList = PyList_New(pysize);
      std::map< sword::SWBuf,sword::InstallSource *,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::InstallSource * > > >::const_iterator i = self->begin();
      for (Py_ssize_t j = 0; j < pysize; ++i, ++j) {
	PyList_SET_ITEM(keyList, j, swig::from(i->first));
      }
      SWIG_PYTHON_THREAD_END_BLOCK;
      return keyList;
    }
SWIGINTERN PyObject *std_map_Sl_sword_SWBuf_Sc_sword_InstallSource_Sm__Sg__values(std::map< sword::SWBuf,sword::InstallSource * > *self){
      std::map< sword::SWBuf,sword::InstallSource *,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::InstallSource * > > >::size_type size = self->size();
      Py_ssize_t pysize = (size <= (std::map< sword::SWBuf,sword::InstallSource *,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::InstallSource * > > >::size_type)PY_SSIZE_T_MAX) ? (Py_ssize_t)size : -1;
      SWIG_PYTHON_THREAD_BEGIN_BLOCK;
      if (pysize < 0) {
	PyErr_SetString(PyExc_OverflowError, "map size not valid in python");
	SWIG_PYTHON_THREAD_END_BLOCK;
	return NULL;
      }
      PyObject* valList = PyList_New(pysize);
      std::map< sword::SWBuf,sword::InstallSource *,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::InstallSource * > > >::const_iterator i = self->begin();
      for (Py_ssize_t j = 0; j < pysize; ++i, ++j) {
	PyList_SET_ITEM(valList, j, swig::from(i->second));
      }
      SWIG_PYTHON_THREAD_END_BLOCK;
      return valList;
    }
SWIGINTERN PyObject *std_map_Sl_sword_SWBuf_Sc_sword_InstallSource_Sm__Sg__items(std::map< sword::SWBuf,sword::InstallSource * > *self){
      std::map< sword::SWBuf,sword::InstallSource *,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::InstallSource * > > >::size_type size = self->size();
      Py_ssize_t pysize = (size <= (std::map< sword::SWBuf,sword::InstallSource *,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::InstallSource * > > >::size_type)PY_SSIZE_T_MAX) ? (Py_ssize_t)size : -1;
      SWIG_PYTHON_THREAD_BEGIN_BLOCK;
      if (pysize < 0) {
	PyErr_SetString(PyExc_OverflowError, "map size not valid in python");
	SWIG_PYTHON_THREAD_END_BLOCK;
	return NULL;
      }    
      PyObject* itemList = PyList_New(pysize);
      std::map< sword::SWBuf,sword::InstallSource *,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::InstallSource * > > >::const_iterator i = self->begin();
      for (Py_ssize_t j = 0; j < pysize; ++i, ++j) {
	PyList_SET_ITEM(itemList, j, swig::from(*i));
      }
      SWIG_PYTHON_THREAD_END_BLOCK;
      return itemList;
    }
SWIGINTERN bool std_map_Sl_sword_SWBuf_Sc_sword_InstallSource_Sm__Sg____contains__(std::map< sword::SWBuf,sword::InstallSource * > *self,std::map< sword::SWBuf,sword::InstallSource * >::key_type const &key){
      return self->find(key) != self->end();
    }
SWIGINTERN swig::SwigPyIterator *std_map_Sl_sword_SWBuf_Sc_sword_InstallSource_Sm__Sg__key_iterator(std::map< sword::SWBuf,sword::InstallSource * > *self,PyObject **PYTHON_SELF){
      return swig::make_output_key_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
    }
SWIGINTERN swig::SwigPyIterator *std_map_Sl_sword_SWBuf_Sc_sword_InstallSource_Sm__Sg__value_iterator(std::map< sword::SWBuf,sword::InstallSource * > *self,PyObject **PYTHON_SELF){
      return swig::make_output_value_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
    }
SWIGINTERN void std_map_Sl_sword_SWBuf_Sc_sword_InstallSource_Sm__Sg____setitem____SWIG_0(std::map< sword::SWBuf,sword::InstallSource * > *self,std::map< sword::SWBuf,sword::InstallSource * >::key_type const &key){
      self->erase(key);
    }
SWIGINTERN void std_map_Sl_sword_SWBuf_Sc_sword_InstallSource_Sm__Sg____setitem____SWIG_1(std::map< sword::SWBuf,sword::InstallSource * > *self,std::map< sword::SWBuf,sword::InstallSource * >::key_type const &key,std::map< sword::SWBuf,sword::InstallSource * >::mapped_type const &x){
#ifdef __cpp_lib_map_try_emplace
      (*self).insert_or_assign(key, x);
#else
      (*self)[key] = x;
#endif
    }
SWIGINTERN PyObject *std_map_Sl_sword_SWBuf_Sc_sword_InstallSource_Sm__Sg__asdict(std::map< sword::SWBuf,sword::InstallSource * > *self){
      return swig::traits_from< std::map< sword::SWBuf,sword::InstallSource *,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::InstallSource * > > > >::asdict(*self);
    }
SWIGINTERN void std_map_Sl_sword_SWBuf_Sc_sword_InstallSource_Sm__Sg__erase__SWIG_1(std::map< sword::SWBuf,sword::InstallSource * > *self,std::map< sword::SWBuf,sword::InstallSource * >::iterator position){ self->erase(position); }
SWIGINTERN void std_map_Sl_sword_SWBuf_Sc_sword_InstallSource_Sm__Sg__erase__SWIG_2(std::map< sword::SWBuf,sword::InstallSource * > *self,std::map< sword::SWBuf,sword::InstallSource * >::iterator first,std::map< sword::SWBuf,sword::InstallSource * >::iterator last){ self->erase(first, last); }

  namespace swig {
    template <>  struct traits< sword::DirEntry > {
      typedef pointer_category category;
      static const char* type_name() { return"sword::DirEntry"; }
    };
  }


      namespace swig {
	template <>  struct traits<std::vector< sword::DirEntry, std::allocator< sword::DirEntry > > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::vector<" "sword::DirEntry" "," "std::allocator< sword::DirEntry >" " >";
	  }
	};
      }
    
SWIGINTERN swig::SwigPyIterator *std_vector_Sl_sword_DirEntry_Sg__iterator(std::vector< sword::DirEntry > *self,PyObject **PYTHON_SELF){
      return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
    }
SWIGINTERN bool std_vector_Sl_sword_DirEntry_Sg____nonzero__(std::vector< sword::DirEntry > const *self){
      return !(self->empty());
    }
SWIGINTERN bool std_vector_Sl_sword_DirEntry_Sg____bool__(std::vector< sword::DirEntry > const *self){
      return !(self->empty());
    }
SWIGINTERN std::vector< sword::DirEntry >::size_type std_vector_Sl_sword_DirEntry_Sg____len__(std::vector< sword::DirEntry > const *self){
      return self->size();
    }
SWIGINTERN std::vector< sword::DirEntry,std::allocator< sword::DirEntry > > *std_vector_Sl_sword_DirEntry_Sg____getslice__(std::vector< sword::DirEntry > *self,std::vector< sword::DirEntry >::difference_type i,std::vector< sword::DirEntry >::difference_type j){
      return swig::getslice(self, i, j, 1);
    }
SWIGINTERN void std_vector_Sl_sword_DirEntry_Sg____setslice____SWIG_0(std::vector< sword::DirEntry > *self,std::vector< sword::DirEntry >::difference_type i,std::vector< sword::DirEntry >::difference_type j){
      swig::setslice(self, i, j, 1, std::vector< sword::DirEntry,std::allocator< sword::DirEntry > >());
    }
SWIGINTERN void std_vector_Sl_sword_DirEntry_Sg____setslice____SWIG_1(std::vector< sword::DirEntry > *self,std::vector< sword::DirEntry >::difference_type i,std::vector< sword::DirEntry >::difference_type j,std::vector< sword::DirEntry,std::allocator< sword::DirEntry > > const &v){
      swig::setslice(self, i, j, 1, v);
    }
SWIGINTERN void std_vector_Sl_sword_DirEntry_Sg____delslice__(std::vector< sword::DirEntry > *self,std::vector< sword::DirEntry >::difference_type i,std::vector< sword::DirEntry >::difference_type j){
      swig::delslice(self, i, j, 1);
    }
SWIGINTERN void std_vector_Sl_sword_DirEntry_Sg____delitem____SWIG_0(std::vector< sword::DirEntry > *self,std::vector< sword::DirEntry >::difference_type i){
      swig::erase(self, swig::getpos(self, i));
    }
SWIGINTERN std::vector< sword::DirEntry,std::allocator< sword::DirEntry > > *std_vector_Sl_sword_DirEntry_Sg____getitem____SWIG_0(std::vector< sword::DirEntry > *self,SWIGPY_SLICEOBJECT *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return NULL;
      }
      PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< sword::DirEntry,std::allocator< sword::DirEntry > >::difference_type id = i;
      std::vector< sword::DirEntry,std::allocator< sword::DirEntry > >::difference_type jd = j;
      return swig::getslice(self, id, jd, step);
    }
SWIGINTERN void std_vector_Sl_sword_DirEntry_Sg____setitem____SWIG_0(std::vector< sword::DirEntry > *self,SWIGPY_SLICEOBJECT *slice,std::vector< sword::DirEntry,std::allocator< sword::DirEntry > > const &v){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< sword::DirEntry,std::allocator< sword::DirEntry > >::difference_type id = i;
      std::vector< sword::DirEntry,std::allocator< sword::DirEntry > >::difference_type jd = j;
      swig::setslice(self, id, jd, step, v);
    }
SWIGINTERN void std_vector_Sl_sword_DirEntry_Sg____setitem____SWIG_1(std::vector< sword::DirEntry > *self,SWIGPY_SLICEOBJECT *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< sword::DirEntry,std::allocator< sword::DirEntry > >::difference_type id = i;
      std::vector< sword::DirEntry,std::allocator< sword::DirEntry > >::difference_type jd = j;
      swig::delslice(self, id, jd, step);
    }
SWIGINTERN void std_vector_Sl_sword_DirEntry_Sg____delitem____SWIG_1(std::vector< sword::DirEntry > *self,SWIGPY_SLICEOBJECT *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< sword::DirEntry,std::allocator< sword::DirEntry > >::difference_type id = i;
      std::vector< sword::DirEntry,std::allocator< sword::DirEntry > >::difference_type jd = j;
      swig::delslice(self, id, jd, step);
    }
SWIGINTERN std::vector< sword::DirEntry >::value_type const &std_vector_Sl_sword_DirEntry_Sg____getitem____SWIG_1(std::vector< sword::DirEntry > const *self,std::vector< sword::DirEntry >::difference_type i){
      return *(swig::cgetpos(self, i));
    }
SWIGINTERN void std_vector_Sl_sword_DirEntry_Sg____setitem____SWIG_2(std::vector< sword::DirEntry > *self,std::vector< sword::DirEntry >::difference_type i,std::vector< sword::DirEntry >::value_type const &x){
      *(swig::getpos(self,i)) = x;
    }
SWIGINTERN std::vector< sword::DirEntry >::value_type std_vector_Sl_sword_DirEntry_Sg__pop(std::vector< sword::DirEntry > *self){
      if (self->size() == 0)
	throw std::out_of_range("pop from empty container");
      std::vector< sword::DirEntry,std::allocator< sword::DirEntry > >::value_type x = self->back();
      self->pop_back();
      return x;
    }
SWIGINTERN void std_vector_Sl_sword_DirEntry_Sg__append(std::vector< sword::DirEntry > *self,std::vector< sword::DirEntry >::value_type const &x){
      self->push_back(x);
    }
SWIGINTERN std::vector< sword::DirEntry >::iterator std_vector_Sl_sword_DirEntry_Sg__erase__SWIG_0(std::vector< sword::DirEntry > *self,std::vector< sword::DirEntry >::iterator pos){ return self->erase(pos); }
SWIGINTERN std::vector< sword::DirEntry >::iterator std_vector_Sl_sword_DirEntry_Sg__erase__SWIG_1(std::vector< sword::DirEntry > *self,std::vector< sword::DirEntry >::iterator first,std::vector< sword::DirEntry >::iterator last){ return self->erase(first, last); }
SWIGINTERN std::vector< sword::DirEntry >::iterator std_vector_Sl_sword_DirEntry_Sg__insert__SWIG_0(std::vector< sword::DirEntry > *self,std::vector< sword::DirEntry >::iterator pos,std::vector< sword::DirEntry >::value_type const &x){ return self->insert(pos, x); }
SWIGINTERN void std_vector_Sl_sword_DirEntry_Sg__insert__SWIG_1(std::vector< sword::DirEntry > *self,std::vector< sword::DirEntry >::iterator pos,std::vector< sword::DirEntry >::size_type n,std::vector< sword::DirEntry >::value_type const &x){ self->insert(pos, n, x); }

#include "swobject.h"


#include "swconfig.h"

SWIGINTERN void sword_SWConfig_set(sword::SWConfig *self,char const *group,char const *entry,char const *value){
	self->getSection(group)[entry] = value;
  }
SWIGINTERN char const *sword_SWConfig_get(sword::SWConfig *self,char const *group,char const *entry){
	return self->getSection(group)[entry].c_str();
  }

#include "swversion.h"


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


#include "rawverse.h"
#include "zverse.h"
#include "rawstr.h"
#include "rawstr4.h"
#include "zstr.h"
#include "swgenbook.h"
#include "lzsscomprs.h"
#include "zipcomprs.h"
#include "versekey.h"
#include "versetreekey.h"
#include "treekey.h"
#include "rawgenbook.h"
#include "swtext.h"
#include "swcom.h"
#include "rawcom.h"
#include "swld.h"
#include "zld.h"
#include "zcom.h"
#include "ztext.h"
#include "rawld.h"
#include "rawld4.h"
#include "treekeyidx.h"
#include "rawtext.h"




SWIGINTERN int
SWIG_AsVal_unsigned_SS_short (PyObject * obj, unsigned short *val)
{
  unsigned long v;
  int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
  if (SWIG_IsOK(res)) {
    if ((v > USHRT_MAX)) {
      return SWIG_OverflowError;
    } else {
      if (val) *val = static_cast< unsigned short >(v);
    }
  }  
  return res;
}


SWIGINTERNINLINE PyObject *
SWIG_From_signed_SS_char  (signed char value)
{    
  return SWIG_From_long  (value);
}


#include "swkey.h"


#include "listkey.h"

SWIGINTERN sword::ListKey *sword_ListKey_castTo(sword::SWKey *o){
		return dynamic_cast<sword::ListKey*>(o);
	}

#include "versekey.h"
#include "versificationmgr.h"

SWIGINTERN sword::VerseKey *sword_VerseKey_castTo(sword::SWKey *o){
		return dynamic_cast<sword::VerseKey*>(o);
	}
SWIGINTERN int const sword_VerseKey_bookCount(sword::VerseKey *self,int const testament){
		if ( (testament < 1) || (testament > 2) ) {
			return 0;
		};
		return self->BMAX[testament-1];
	}
SWIGINTERN int const sword_VerseKey_getBookCount(sword::VerseKey *self){
        const sword::VersificationMgr::System* system = sword::VersificationMgr::getSystemVersificationMgr()->getVersificationSystem(
            self->getVersificationSystem()
        );
        return system->getBookCount();
    }
SWIGINTERN char const *sword_VerseKey_bookName(sword::VerseKey *self,int const testament,int const book){
		if ( (testament < 1) || (testament > 2) ) {
			return 0;
		};
		if ( (book < 1) || (book > self->BMAX[testament-1]) ) {
			return 0;
		}

        const sword::VersificationMgr::System* system = sword::VersificationMgr::getSystemVersificationMgr()->getVersificationSystem(
            self->getVersificationSystem()
        );
        
        int book_num = (book - 1) + (
            (testament == 2) ? self->BMAX[0] : 0
        );

        const sword::VersificationMgr::Book* b = system->getBook(book_num);
        if(!b) {
            fprintf(stderr, "b is null for %d?!?\n", book_num);
            return 0;
        }
        return b->getLongName();

 
	}
SWIGINTERN int sword_VerseKey_getBookNumberByOSISName(sword::VerseKey *self,char const *bookname){
        const sword::VersificationMgr::System* system = sword::VersificationMgr::getSystemVersificationMgr()->getVersificationSystem(
            self->getVersificationSystem()
        );
        return system->getBookNumberByOSISName(bookname);
   }
SWIGINTERN char const *sword_VerseKey_getOSISBookName__SWIG_1(sword::VerseKey *self,int const book){
        const sword::VersificationMgr::System* system = sword::VersificationMgr::getSystemVersificationMgr()->getVersificationSystem(
            self->getVersificationSystem()
        );
   		if ( (book < 0) || (book >= system->getBookCount()))
            return 0;

        return system->getBook(book)->getOSISName();
    }
SWIGINTERN int const sword_VerseKey_chapterCount(sword::VerseKey *self,int const testament,int const book){
		if ( (testament < 1) || (testament > 2) ) {
			return 0;
		};
		if ( (book < 1) || (book > self->BMAX[testament-1]) ) {
			return 0;
		}

        const sword::VersificationMgr::System* system = sword::VersificationMgr::getSystemVersificationMgr()->getVersificationSystem(
            self->getVersificationSystem()
        );
        
        int book_num = (book - 1) + (
            (testament == 2) ? self->BMAX[0] : 0
        );

        const sword::VersificationMgr::Book* b = system->getBook(book_num);
        if(!b) {
            fprintf(stderr, "b is null for %d?!?\n", book_num);
            return 0;
        }        

        return b->getChapterMax();
	}
SWIGINTERN int const sword_VerseKey_verseCount(sword::VerseKey *self,int const testament,int const book,int const chapter){
		if ( (testament < 1) || (testament > 2) ) {
			return 0;
		};
		if ( (book < 1) || (book > self->BMAX[testament-1]) ) {
			return 0;
		}

        const sword::VersificationMgr::System* system = sword::VersificationMgr::getSystemVersificationMgr()->getVersificationSystem(
            self->getVersificationSystem()
        );
        
        int book_num = (book - 1) + (
            (testament == 2) ? self->BMAX[0] : 0
        );

        const sword::VersificationMgr::Book* b = system->getBook(book_num);
        if(!b) {
            fprintf(stderr, "b is null for %d?!?\n", book_num);
            return 0;
        }
		if ( (chapter < 1) || (chapter > b->getChapterMax()) ) {
			return 0;
		}

		return b->getVerseMax(chapter);

	}
SWIGINTERN int sword_abbrev_getAbbrevCount(sword::abbrev *self){
		int abbrevsCnt;
		for (abbrevsCnt = 0; *self[abbrevsCnt].ab; abbrevsCnt++) {}
		return abbrevsCnt-1;
	}
SWIGINTERN sword::abbrev const *sword_abbrev_getAbbrevData(sword::abbrev *self,int i){
		return &(self[i]);
	}

SWIGINTERNINLINE PyObject *
SWIG_From_unsigned_SS_char  (unsigned char value)
{    
  return SWIG_From_unsigned_SS_long  (value);
}

SWIGINTERN int const sword_sbook_verseMax(sword::sbook *self,int chapter){
		if ( chapter > 0  && chapter < self->chapmax ) {
			return self->versemax[chapter-1];
		} else {
			return 0;
		}
	}

#include "treekey.h"

SWIGINTERN sword::TreeKey *sword_TreeKey_castTo(sword::SWKey *o){
		return dynamic_cast<sword::TreeKey*>(o);
	}

#include "treekeyidx.h"

SWIGINTERN sword::TreeKeyIdx *sword_TreeKeyIdx_castTo(sword::SWKey *o){
		return dynamic_cast<sword::TreeKeyIdx*>(o);
	}

#include "versetreekey.h"

SWIGINTERN sword::VerseTreeKey *sword_VerseTreeKey_castTo(sword::SWKey *o){
		return dynamic_cast<sword::VerseTreeKey*>(o);
	}

#include "swdisp.h"


#include <swfilter.h>


#include "swoptfilter.h"

SWIGINTERN sword::SWOptionFilter *sword_SWOptionFilter_castTo(sword::SWFilter *o){
		return dynamic_cast<sword::SWOptionFilter*>(o);
	}

#include <swfiltermgr.h>


#include "stringmgr.h"
class PyStringMgr : public sword::StringMgr
{
    public:
       char *upperUTF8(char *text, unsigned int max = 0) const
        {
            sword::SWBuf buf=(const char*)text;
            getUpper(&buf);
            strncpy(text, buf.c_str(), (max) ? max : strlen(text));
            return text;
        }

        virtual void getUpper(sword::SWBuf* test) const = 0;
};


SWIGINTERNINLINE PyObject*
  SWIG_From_unsigned_SS_int  (unsigned int value)
{
  return PyInt_FromSize_t((size_t) value);
}


#include "swsearchable.h"

SWIGINTERN bool sword_SWSearchable_isSearchSupported__SWIG_0(sword::SWSearchable *self,char const *istr,int searchType=0,int flags=0,sword::SWKey *scope=0){
                bool checksupported = true;
                self->search(istr, searchType, flags, scope, &checksupported);
                return checksupported;
        }
SWIGINTERN sword::ListKey &sword_SWSearchable_doSearch__SWIG_0(sword::SWSearchable *self,char const *istr,int searchType=0,int flags=0,sword::SWKey *scope=0){
                return self->search(istr, searchType, flags, scope);
        }

#include "swmodule.h"

SWIGINTERN sword::SWModule *sword_SWModule_castTo(sword::SWSearchable *o){
		return dynamic_cast<sword::SWModule*>(o);
	}
SWIGINTERN std::map< sword::SWBuf,std::map< sword::SWBuf,AttributeValueMap,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,AttributeValueMap > > >,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,std::map< sword::SWBuf,AttributeValueMap,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,AttributeValueMap > > > > > > &sword_SWModule_getEntryAttributesMap(sword::SWModule *self){
            return self->getEntryAttributes();
    }
SWIGINTERN std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > *sword_SWModule_getConfigMap(sword::SWModule *self){
    return ( std::map < sword::SWBuf, sword::SWBuf > * ) &self->getConfig();
  }

#include <swmgr.h>

SWIGINTERN std::vector< sword::SWBuf,std::allocator< sword::SWBuf > > sword_SWMgr_getGlobalOptionsVector(sword::SWMgr *self){
        std::list<sword::SWBuf> l(self->getGlobalOptions());
        return std::vector< sword::SWBuf >(l.begin(), l.end());
    }
SWIGINTERN std::vector< sword::SWBuf,std::allocator< sword::SWBuf > > sword_SWMgr_getGlobalOptionValuesVector(sword::SWMgr *self,char const *option){
        std::list<sword::SWBuf> l(self->getGlobalOptionValues(option));
        return std::vector< sword::SWBuf >(l.begin(), l.end());
    }
SWIGINTERN sword::SWModule *sword_SWMgr_getModuleAt(sword::SWMgr *self,int const pos){
        if (pos < 0 || pos > (int)self->Modules.size() )
            return 0;
    
        sword::ModMap::iterator it = self->Modules.begin(); 
        
        for (int i = 0; i < pos; ++i) {
            it++;
        }

        if ( it != self->Modules.end() ) {
            return (*it).second;
        }
        
        return 0;
    }

#include "encfiltmgr.h"

SWIGINTERN sword::EncodingFilterMgr *sword_EncodingFilterMgr_castTo(sword::SWFilterMgr *o){
		return dynamic_cast<sword::EncodingFilterMgr*>(o);
	}

#include <markupfiltmgr.h>
using namespace sword;

SWIGINTERN sword::MarkupFilterMgr *sword_MarkupFilterMgr_castTo(sword::SWFilterMgr *o){
		return dynamic_cast<sword::MarkupFilterMgr*>(o);
	}

#include "swlocale.h"

SWIGINTERN sword::abbrev const *sword_SWLocale_getBookAbbrevs(sword::SWLocale *self){
        int x;
        return self->getBookAbbrevs(&x);
    }

#include <swcomprs.h>


#include <lzsscomprs.h>

SWIGINTERN sword::LZSSCompress *sword_LZSSCompress_castTo(sword::SWCompress *o){
		return dynamic_cast<sword::LZSSCompress*>(o);
	}

#include <zipcomprs.h>

SWIGINTERN sword::ZipCompress *sword_ZipCompress_castTo(sword::SWCompress *o){
		return dynamic_cast<sword::ZipCompress*>(o);
	}

#include "swcom.h"

SWIGINTERN sword::SWCom *sword_SWCom_castTo(sword::SWModule *o){
		return dynamic_cast<sword::SWCom*>(o);
	}

#include "rawcom.h"

SWIGINTERN sword::RawCom *sword_RawCom_castTo(sword::SWModule *o){
		return dynamic_cast<sword::RawCom*>(o);
	}

#include "zverse.h"
#include "zcom.h"

SWIGINTERN sword::zCom *sword_zCom_castTo(sword::SWModule *o){
		return dynamic_cast<sword::zCom*>(o);
	}

#include "swgenbook.h"

SWIGINTERN sword::SWGenBook *sword_SWGenBook_castTo(sword::SWModule *o){
		return dynamic_cast<sword::SWGenBook*>(o);
	}

#include "rawgenbook.h"

SWIGINTERN sword::RawGenBook *sword_RawGenBook_castTo(sword::SWModule *o){
		return dynamic_cast<sword::RawGenBook*>(o);
	}

#include "swld.h"

SWIGINTERN sword::SWLD *sword_SWLD_castTo(sword::SWModule *o){
		return dynamic_cast<sword::SWLD*>(o);
	}

#include "rawld.h"

SWIGINTERN sword::RawLD *sword_RawLD_castTo(sword::SWModule *o){
		return dynamic_cast<sword::RawLD*>(o);
	}

#include "rawld4.h"

SWIGINTERN sword::RawLD4 *sword_RawLD4_castTo(sword::SWModule *o){
		return dynamic_cast<sword::RawLD4*>(o);
	}

#include "zld.h"

SWIGINTERN sword::zLD *sword_zLD_castTo(sword::SWModule *o){
		return dynamic_cast<sword::zLD*>(o);
	}

#include "swtext.h"

SWIGINTERN sword::SWText *sword_SWText_castTo(sword::SWModule *o){
		return dynamic_cast<sword::SWText*>(o);
	}

#include "rawtext.h"

SWIGINTERN sword::RawText *sword_RawText_castTo(sword::SWModule *o){
		return dynamic_cast<sword::RawText*>(o);
	}

#include "ztext.h"

SWIGINTERN sword::zText *sword_zText_castTo(sword::SWModule *o){
		return dynamic_cast<sword::zText*>(o);
	}

#include <localemgr.h>

SWIGINTERN std::vector< sword::SWBuf,std::allocator< sword::SWBuf > > sword_LocaleMgr_getAvailableLocalesVector(sword::LocaleMgr *self){
        std::list<sword::SWBuf> l(self->getAvailableLocales());
        return std::vector< sword::SWBuf >(l.begin(), l.end());
    }

#include <url.h>


#include <utilxml.h>


#include <swbasicfilter.h>
#include <osishtmlhref.h>
#include <thmlhtmlhref.h>
#include <gbfhtmlhref.h>
#include "utf8html.h"

 
#include "markupcallback.h"
#include "rendercallback.h"
#include "searcher.h"


#include "swlog.h"


#include "remotetrans.h"


#include "installmgr.h"


namespace swig {
  template <> struct traits< int > {
    typedef value_category category;
    static const char* type_name() { return"int"; }
  };
  template <>  struct traits_asval< int > {
    typedef int value_type;
    static int asval(PyObject *obj, value_type *val) {
      return SWIG_AsVal_int (obj, val);
    }
  };
  template <>  struct traits_from< int > {
    typedef int value_type;
    static PyObject *from(const value_type& val) {
      return SWIG_From_int  (val);
    }
  };
}


      namespace swig {
	template <>  struct traits<std::pair< sword::SWModule*, int > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::pair<" "sword::SWModule" " *," "int" " >";
	  }
	};
      }
    

      namespace swig {
	template <>  struct traits<std::map< sword::SWModule *, int, std::less< sword::SWModule * >, std::allocator< std::pair< sword::SWModule *const,int > > > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::map<" "sword::SWModule *" "," "int" "," "std::less< sword::SWModule * >" "," "std::allocator< std::pair< sword::SWModule *const,int > >" " >";
	  }
	};
      }
    


/* ---------------------------------------------------
 * C++ director class methods
 * --------------------------------------------------- */

#include "Sword.h"

SwigDirector_PyStringMgr::SwigDirector_PyStringMgr(PyObject *self): PyStringMgr(), Swig::Director(self) {
  SWIG_DIRECTOR_RGTR((PyStringMgr *)this, this); 
}




char *SwigDirector_PyStringMgr::lowerUTF8(char *text,unsigned int max) const {
  char *c_result = 0 ;
  int res ;
  char *buf = 0 ;
  int alloc = SWIG_NEWOBJ ;
  
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_FromCharPtr((const char *)text);
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(max));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call PyStringMgr.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 0;
  const char *const swig_method_name = "lowerUTF8";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("lowerUTF8");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  res = SWIG_AsCharPtrAndSize(result, &buf, NULL, &alloc);
  if (!SWIG_IsOK(res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(res)), "in output value of type '""char *""'");
  }
  if (alloc == SWIG_NEWOBJ) {
    swig_acquire_ownership_array(buf);
  }
  c_result = reinterpret_cast< char * >(buf);
  return (char *) c_result;
}


bool SwigDirector_PyStringMgr::isUpper(SW_u32 character) const {
  bool c_result = SwigValueInit< bool >() ;
  
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_NewPointerObj((new SW_u32(SWIG_STD_MOVE(character))), SWIGTYPE_p_SW_u32, SWIG_POINTER_OWN |  0 );
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call PyStringMgr.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 2;
  const char *const swig_method_name = "isUpper";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("isUpper");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  bool swig_val;
  int swig_res = SWIG_AsVal_bool(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""bool""'");
  }
  c_result = static_cast< bool >(swig_val);
  return (bool) c_result;
}


bool SwigDirector_PyStringMgr::isLower(SW_u32 character) const {
  bool c_result = SwigValueInit< bool >() ;
  
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_NewPointerObj((new SW_u32(SWIG_STD_MOVE(character))), SWIGTYPE_p_SW_u32, SWIG_POINTER_OWN |  0 );
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call PyStringMgr.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 3;
  const char *const swig_method_name = "isLower";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("isLower");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  bool swig_val;
  int swig_res = SWIG_AsVal_bool(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""bool""'");
  }
  c_result = static_cast< bool >(swig_val);
  return (bool) c_result;
}


bool SwigDirector_PyStringMgr::isDigit(SW_u32 character) const {
  bool c_result = SwigValueInit< bool >() ;
  
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_NewPointerObj((new SW_u32(SWIG_STD_MOVE(character))), SWIGTYPE_p_SW_u32, SWIG_POINTER_OWN |  0 );
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call PyStringMgr.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 4;
  const char *const swig_method_name = "isDigit";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("isDigit");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  bool swig_val;
  int swig_res = SWIG_AsVal_bool(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""bool""'");
  }
  c_result = static_cast< bool >(swig_val);
  return (bool) c_result;
}


bool SwigDirector_PyStringMgr::isAlpha(SW_u32 character) const {
  bool c_result = SwigValueInit< bool >() ;
  
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_NewPointerObj((new SW_u32(SWIG_STD_MOVE(character))), SWIGTYPE_p_SW_u32, SWIG_POINTER_OWN |  0 );
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call PyStringMgr.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 5;
  const char *const swig_method_name = "isAlpha";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("isAlpha");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  bool swig_val;
  int swig_res = SWIG_AsVal_bool(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""bool""'");
  }
  c_result = static_cast< bool >(swig_val);
  return (bool) c_result;
}


SwigDirector_PyStringMgr::~SwigDirector_PyStringMgr() {
}

bool SwigDirector_PyStringMgr::supportsUnicode() const {
  bool c_result = SwigValueInit< bool >() ;
  
  swig_set_inner("supportsUnicode", true);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call PyStringMgr.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 6;
  const char *const swig_method_name = "supportsUnicode";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("supportsUnicode");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  swig_set_inner("supportsUnicode", false);
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  bool swig_val;
  int swig_res = SWIG_AsVal_bool(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""bool""'");
  }
  c_result = static_cast< bool >(swig_val);
  return (bool) c_result;
}


void SwigDirector_PyStringMgr::getUpper(sword::SWBuf *test) const {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(test), SWIGTYPE_p_sword__SWBuf,  0 );
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call PyStringMgr.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 7;
  const char *const swig_method_name = "getUpper";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("getUpper");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


SwigDirector_MarkupCallback::SwigDirector_MarkupCallback(PyObject *self): MarkupCallback(), Swig::Director(self) {
  SWIG_DIRECTOR_RGTR((MarkupCallback *)this, this); 
}




SwigDirector_MarkupCallback::~SwigDirector_MarkupCallback() {
}

bool SwigDirector_MarkupCallback::run(sword::SWModule *x) {
  bool c_result = SwigValueInit< bool >() ;
  
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(x), SWIGTYPE_p_sword__SWModule,  0 );
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call MarkupCallback.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 0;
  const char *const swig_method_name = "run";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("run");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  bool swig_val;
  int swig_res = SWIG_AsVal_bool(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""bool""'");
  }
  c_result = static_cast< bool >(swig_val);
  return (bool) c_result;
}


SwigDirector_RenderCallback::SwigDirector_RenderCallback(PyObject *self): RenderCallback(), Swig::Director(self) {
  SWIG_DIRECTOR_RGTR((RenderCallback *)this, this); 
}




SwigDirector_RenderCallback::~SwigDirector_RenderCallback() {
}

ReturnSuccess SwigDirector_RenderCallback::run(sword::SWBuf &x,char const *token,sword::BasicFilterUserData *userData) {
  void *swig_argp ;
  int swig_res = 0 ;
  
  ReturnSuccess c_result;
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(&x), SWIGTYPE_p_sword__SWBuf,  0 );
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_FromCharPtr((const char *)token);
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_NewPointerObj(SWIG_as_voidptr(userData), SWIGTYPE_p_sword__BasicFilterUserData,  0 );
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call RenderCallback.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 0;
  const char *const swig_method_name = "run";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("run");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
  swig_res = SWIG_ConvertPtr(result,&swig_argp,SWIGTYPE_p_ReturnSuccess,  0  | 0);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""ReturnSuccess""'");
  }
  c_result = *(reinterpret_cast< ReturnSuccess * >(swig_argp));
  if (SWIG_IsNewObj(swig_res)) delete reinterpret_cast< ReturnSuccess * >(swig_argp);
  return (ReturnSuccess) c_result;
}


SwigDirector_SWSearcher::SwigDirector_SWSearcher(PyObject *self,sword::SWModule *Mod): SWSearcher(Mod), Swig::Director(self) {
  SWIG_DIRECTOR_RGTR((SWSearcher *)this, this); 
}




void SwigDirector_SWSearcher::PercentFunction(int value) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int(static_cast< int >(value));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call SWSearcher.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 0;
  const char *const swig_method_name = "PercentFunction";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("PercentFunction");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


SwigDirector_SWSearcher::~SwigDirector_SWSearcher() {
}

SwigDirector_StatusReporter::SwigDirector_StatusReporter(PyObject *self): sword::StatusReporter(), Swig::Director(self) {
  SWIG_DIRECTOR_RGTR((sword::StatusReporter *)this, this); 
}




SwigDirector_StatusReporter::~SwigDirector_StatusReporter() {
}

void SwigDirector_StatusReporter::preStatus(long totalBytes,long completedBytes,char const *message) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_long(static_cast< long >(totalBytes));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_long(static_cast< long >(completedBytes));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_FromCharPtr((const char *)message);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call StatusReporter.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 0;
  const char *const swig_method_name = "preStatus";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("preStatus");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


void SwigDirector_StatusReporter::update(unsigned long totalBytes,unsigned long completedBytes) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(totalBytes));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(completedBytes));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call StatusReporter.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 1;
  const char *const swig_method_name = "update";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("update");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    {
      if (error != NULL) {
        throw Swig::DirectorMethodException();
      }
    }
  }
}


#ifdef __cplusplus
extern "C" {
#endif
SWIGINTERN int Swig_var_SWBuf_nullStr_set(PyObject *_val) {
  {
    char *cptr = 0; size_t csize = 0; int alloc = SWIG_NEWOBJ;
    int res = SWIG_AsCharPtrAndSize(_val, &cptr, &csize, &alloc);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in variable '""sword::SWBuf::nullStr""' of type '""char *""'");
    }
    delete[] sword::SWBuf::nullStr;
    if (alloc == SWIG_NEWOBJ) {
      sword::SWBuf::nullStr = cptr;
    } else {
      sword::SWBuf::nullStr = csize ? (char *)reinterpret_cast< char* >(memcpy(new char[csize], cptr, sizeof(char)*(csize))) : 0;
    }
  }
  return 0;
fail:
  return 1;
}


SWIGINTERN PyObject *Swig_var_SWBuf_nullStr_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(sword::SWBuf::nullStr);
  return pyobj;
}


SWIGINTERN PyObject *_wrap_SWBuf_nullStr_get(PyObject *SWIGUNUSEDPARM(self), PyObject *SWIGUNUSEDPARM(args)) {
  return Swig_var_SWBuf_nullStr_get();
}


SWIGINTERN PyObject *_wrap_SWBuf_nullStr_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  int res;
  
  res = Swig_var_SWBuf_nullStr_set(args);
  return !res ? SWIG_Py_Void() : NULL;
}


SWIGINTERN PyObject *_wrap_new_SWBuf__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  sword::SWBuf *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (sword::SWBuf *)new sword::SWBuf(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__SWBuf, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SWBuf__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  unsigned long arg2 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  unsigned long val2 ;
  int ecode2 = 0 ;
  sword::SWBuf *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SWBuf" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  ecode2 = SWIG_AsVal_unsigned_SS_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SWBuf" "', argument " "2"" of type '" "unsigned long""'");
  } 
  arg2 = static_cast< unsigned long >(val2);
  {
    try {
      result = (sword::SWBuf *)new sword::SWBuf((char const *)arg1,arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__SWBuf, SWIG_POINTER_NEW |  0 );
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SWBuf__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  sword::SWBuf *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SWBuf" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  {
    try {
      result = (sword::SWBuf *)new sword::SWBuf((char const *)arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__SWBuf, SWIG_POINTER_NEW |  0 );
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SWBuf__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::SWBuf *arg1 = 0 ;
  unsigned long arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long val2 ;
  int ecode2 = 0 ;
  sword::SWBuf *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_sword__SWBuf,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SWBuf" "', argument " "1"" of type '" "sword::SWBuf const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SWBuf" "', argument " "1"" of type '" "sword::SWBuf const &""'"); 
  }
  arg1 = reinterpret_cast< sword::SWBuf * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SWBuf" "', argument " "2"" of type '" "unsigned long""'");
  } 
  arg2 = static_cast< unsigned long >(val2);
  {
    try {
      result = (sword::SWBuf *)new sword::SWBuf((sword::SWBuf const &)*arg1,arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__SWBuf, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SWBuf__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::SWBuf *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  sword::SWBuf *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_sword__SWBuf,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SWBuf" "', argument " "1"" of type '" "sword::SWBuf const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SWBuf" "', argument " "1"" of type '" "sword::SWBuf const &""'"); 
  }
  arg1 = reinterpret_cast< sword::SWBuf * >(argp1);
  {
    try {
      result = (sword::SWBuf *)new sword::SWBuf((sword::SWBuf const &)*arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__SWBuf, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SWBuf__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char arg1 ;
  char val1 ;
  int ecode1 = 0 ;
  sword::SWBuf *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_char(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SWBuf" "', argument " "1"" of type '" "char""'");
  } 
  arg1 = static_cast< char >(val1);
  {
    try {
      result = (sword::SWBuf *)new sword::SWBuf(arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__SWBuf, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SWBuf(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SWBuf", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_SWBuf__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_sword__SWBuf, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SWBuf__SWIG_4(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_AsVal_char(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_SWBuf__SWIG_5(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SWBuf__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_sword__SWBuf, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_long(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_SWBuf__SWIG_3(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_long(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_SWBuf__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SWBuf'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    sword::SWBuf::SWBuf()\n"
    "    sword::SWBuf::SWBuf(char const *,unsigned long)\n"
    "    sword::SWBuf::SWBuf(char const *)\n"
    "    sword::SWBuf::SWBuf(sword::SWBuf const &,unsigned long)\n"
    "    sword::SWBuf::SWBuf(sword::SWBuf const &)\n"
    "    sword::SWBuf::SWBuf(char)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SWBuf(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWBuf *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWBuf, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SWBuf" "', argument " "1"" of type '" "sword::SWBuf *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWBuf * >(argp1);
  {
    try {
      delete arg1; 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWBuf_setFillByte(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWBuf *arg1 = 0 ;
  char arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SWBuf_setFillByte", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWBuf, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWBuf_setFillByte" "', argument " "1"" of type '" "sword::SWBuf *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWBuf * >(argp1);
  ecode2 = SWIG_AsVal_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SWBuf_setFillByte" "', argument " "2"" of type '" "char""'");
  } 
  arg2 = static_cast< char >(val2);
  {
    try {
      (arg1)->setFillByte(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWBuf_getFillByte(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWBuf *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWBuf, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWBuf_getFillByte" "', argument " "1"" of type '" "sword::SWBuf *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWBuf * >(argp1);
  {
    try {
      result = (char)(arg1)->getFillByte(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_char(static_cast< char >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWBuf_c_str(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWBuf *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWBuf, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWBuf_c_str" "', argument " "1"" of type '" "sword::SWBuf const *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWBuf * >(argp1);
  {
    try {
      result = (char *)((sword::SWBuf const *)arg1)->c_str(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWBuf_charAtGuarded(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWBuf *arg1 = 0 ;
  unsigned long arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  char *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SWBuf_charAtGuarded", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWBuf, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWBuf_charAtGuarded" "', argument " "1"" of type '" "sword::SWBuf *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWBuf * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SWBuf_charAtGuarded" "', argument " "2"" of type '" "unsigned long""'");
  } 
  arg2 = static_cast< unsigned long >(val2);
  {
    try {
      result = (char *) &(arg1)->charAtGuarded(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_char, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWBuf_charAt(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWBuf *arg1 = 0 ;
  unsigned long arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  char *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SWBuf_charAt", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWBuf, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWBuf_charAt" "', argument " "1"" of type '" "sword::SWBuf const *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWBuf * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SWBuf_charAt" "', argument " "2"" of type '" "unsigned long""'");
  } 
  arg2 = static_cast< unsigned long >(val2);
  {
    try {
      result = (char *) &((sword::SWBuf const *)arg1)->charAt(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_char(static_cast< char >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWBuf_size__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::SWBuf *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWBuf, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWBuf_size" "', argument " "1"" of type '" "sword::SWBuf const *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWBuf * >(argp1);
  {
    try {
      result = (unsigned long)((sword::SWBuf const *)arg1)->size(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWBuf_size__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::SWBuf *arg1 = 0 ;
  unsigned long arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWBuf, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWBuf_size" "', argument " "1"" of type '" "sword::SWBuf *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWBuf * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SWBuf_size" "', argument " "2"" of type '" "unsigned long""'");
  } 
  arg2 = static_cast< unsigned long >(val2);
  {
    try {
      (arg1)->size(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWBuf_size(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SWBuf_size", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__SWBuf, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SWBuf_size__SWIG_0(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__SWBuf, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_long(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SWBuf_size__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SWBuf_size'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    sword::SWBuf::size() const\n"
    "    sword::SWBuf::size(unsigned long)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SWBuf_length(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWBuf *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  unsigned long result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWBuf, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWBuf_length" "', argument " "1"" of type '" "sword::SWBuf const *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWBuf * >(argp1);
  {
    try {
      result = (unsigned long)((sword::SWBuf const *)arg1)->length(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWBuf_set__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::SWBuf *arg1 = 0 ;
  sword::SWBuf *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWBuf, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWBuf_set" "', argument " "1"" of type '" "sword::SWBuf *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWBuf * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_sword__SWBuf,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SWBuf_set" "', argument " "2"" of type '" "sword::SWBuf const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SWBuf_set" "', argument " "2"" of type '" "sword::SWBuf const &""'"); 
  }
  arg2 = reinterpret_cast< sword::SWBuf * >(argp2);
  {
    try {
      (arg1)->set((sword::SWBuf const &)*arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWBuf_set__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::SWBuf *arg1 = 0 ;
  char *arg2 = 0 ;
  unsigned long arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  unsigned long val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWBuf, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWBuf_set" "', argument " "1"" of type '" "sword::SWBuf *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWBuf * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SWBuf_set" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  ecode3 = SWIG_AsVal_unsigned_SS_long(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SWBuf_set" "', argument " "3"" of type '" "unsigned long""'");
  } 
  arg3 = static_cast< unsigned long >(val3);
  {
    try {
      (arg1)->set((char const *)arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWBuf_set__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::SWBuf *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWBuf, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWBuf_set" "', argument " "1"" of type '" "sword::SWBuf *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWBuf * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SWBuf_set" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    try {
      (arg1)->set((char const *)arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWBuf_set(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SWBuf_set", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__SWBuf, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_sword__SWBuf, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SWBuf_set__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__SWBuf, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SWBuf_set__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__SWBuf, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_long(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SWBuf_set__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SWBuf_set'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    sword::SWBuf::set(sword::SWBuf const &)\n"
    "    sword::SWBuf::set(char const *,unsigned long)\n"
    "    sword::SWBuf::set(char const *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SWBuf_setFormatted__varargs__(PyObject *self, PyObject *args, PyObject *varargs) {
  PyObject *resultobj = 0;
  sword::SWBuf *arg1 = 0 ;
  char *arg2 = 0 ;
  void *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  sword::SWBuf *result = 0 ;
  
  (void)self;
  if (!PyArg_UnpackTuple(args, "SWBuf_setFormatted", 2, 2, &obj0, &obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_sword__SWBuf, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWBuf_setFormatted" "', argument " "1"" of type '" "sword::SWBuf *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWBuf * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SWBuf_setFormatted" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    try {
      result = (sword::SWBuf *) &(arg1)->setFormatted((char const *)arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__SWBuf, 0 |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWBuf_setFormatted(PyObject *self, PyObject *args) {
  PyObject *resultobj;
  PyObject *varargs;
  PyObject *newargs;
  
  newargs = PyTuple_GetSlice(args, 0, 2);
  varargs = PyTuple_GetSlice(args, 2, PyTuple_Size(args));
  resultobj = _wrap_SWBuf_setFormatted__varargs__(NULL, newargs, varargs);
  SWIG_Py_XDECREF(newargs);
  SWIG_Py_XDECREF(varargs);
  return resultobj;
}


SWIGINTERN PyObject *_wrap_SWBuf_setSize(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWBuf *arg1 = 0 ;
  unsigned long arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SWBuf_setSize", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWBuf, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWBuf_setSize" "', argument " "1"" of type '" "sword::SWBuf *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWBuf * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SWBuf_setSize" "', argument " "2"" of type '" "unsigned long""'");
  } 
  arg2 = static_cast< unsigned long >(val2);
  {
    try {
      (arg1)->setSize(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWBuf_resize(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWBuf *arg1 = 0 ;
  unsigned long arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SWBuf_resize", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWBuf, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWBuf_resize" "', argument " "1"" of type '" "sword::SWBuf *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWBuf * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SWBuf_resize" "', argument " "2"" of type '" "unsigned long""'");
  } 
  arg2 = static_cast< unsigned long >(val2);
  {
    try {
      (arg1)->resize(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWBuf_append__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::SWBuf *arg1 = 0 ;
  char *arg2 = 0 ;
  long arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  long val3 ;
  int ecode3 = 0 ;
  sword::SWBuf *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWBuf, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWBuf_append" "', argument " "1"" of type '" "sword::SWBuf *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWBuf * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SWBuf_append" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  ecode3 = SWIG_AsVal_long(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SWBuf_append" "', argument " "3"" of type '" "long""'");
  } 
  arg3 = static_cast< long >(val3);
  {
    try {
      result = (sword::SWBuf *) &(arg1)->append((char const *)arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__SWBuf, 0 |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWBuf_append__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::SWBuf *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  sword::SWBuf *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWBuf, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWBuf_append" "', argument " "1"" of type '" "sword::SWBuf *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWBuf * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SWBuf_append" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    try {
      result = (sword::SWBuf *) &(arg1)->append((char const *)arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__SWBuf, 0 |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWBuf_append__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::SWBuf *arg1 = 0 ;
  sword::SWBuf *arg2 = 0 ;
  long arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  long val3 ;
  int ecode3 = 0 ;
  sword::SWBuf *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWBuf, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWBuf_append" "', argument " "1"" of type '" "sword::SWBuf *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWBuf * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_sword__SWBuf,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SWBuf_append" "', argument " "2"" of type '" "sword::SWBuf const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SWBuf_append" "', argument " "2"" of type '" "sword::SWBuf const &""'"); 
  }
  arg2 = reinterpret_cast< sword::SWBuf * >(argp2);
  ecode3 = SWIG_AsVal_long(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SWBuf_append" "', argument " "3"" of type '" "long""'");
  } 
  arg3 = static_cast< long >(val3);
  {
    try {
      result = (sword::SWBuf *) &(arg1)->append((sword::SWBuf const &)*arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__SWBuf, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWBuf_append__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::SWBuf *arg1 = 0 ;
  sword::SWBuf *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  sword::SWBuf *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWBuf, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWBuf_append" "', argument " "1"" of type '" "sword::SWBuf *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWBuf * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_sword__SWBuf,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SWBuf_append" "', argument " "2"" of type '" "sword::SWBuf const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SWBuf_append" "', argument " "2"" of type '" "sword::SWBuf const &""'"); 
  }
  arg2 = reinterpret_cast< sword::SWBuf * >(argp2);
  {
    try {
      result = (sword::SWBuf *) &(arg1)->append((sword::SWBuf const &)*arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__SWBuf, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWBuf_append__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::SWBuf *arg1 = 0 ;
  char arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char val2 ;
  int ecode2 = 0 ;
  sword::SWBuf *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWBuf, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWBuf_append" "', argument " "1"" of type '" "sword::SWBuf *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWBuf * >(argp1);
  ecode2 = SWIG_AsVal_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SWBuf_append" "', argument " "2"" of type '" "char""'");
  } 
  arg2 = static_cast< char >(val2);
  {
    try {
      result = (sword::SWBuf *) &(arg1)->append(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__SWBuf, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWBuf_append__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::SWBuf *arg1 = 0 ;
  unsigned char arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  sword::SWBuf *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWBuf, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWBuf_append" "', argument " "1"" of type '" "sword::SWBuf *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWBuf * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SWBuf_append" "', argument " "2"" of type '" "unsigned char""'");
  } 
  arg2 = static_cast< unsigned char >(val2);
  {
    try {
      result = (sword::SWBuf *) &(arg1)->append(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__SWBuf, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWBuf_append(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SWBuf_append", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__SWBuf, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_sword__SWBuf, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SWBuf_append__SWIG_3(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__SWBuf, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_char(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SWBuf_append__SWIG_5(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__SWBuf, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_char(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SWBuf_append__SWIG_4(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__SWBuf, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SWBuf_append__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__SWBuf, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_sword__SWBuf, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_long(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SWBuf_append__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__SWBuf, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_long(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SWBuf_append__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SWBuf_append'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    sword::SWBuf::append(char const *,long)\n"
    "    sword::SWBuf::append(char const *)\n"
    "    sword::SWBuf::append(sword::SWBuf const &,long)\n"
    "    sword::SWBuf::append(sword::SWBuf const &)\n"
    "    sword::SWBuf::append(char)\n"
    "    sword::SWBuf::append(unsigned char const)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SWBuf_appendFormatted__varargs__(PyObject *self, PyObject *args, PyObject *varargs) {
  PyObject *resultobj = 0;
  sword::SWBuf *arg1 = 0 ;
  char *arg2 = 0 ;
  void *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  sword::SWBuf *result = 0 ;
  
  (void)self;
  if (!PyArg_UnpackTuple(args, "SWBuf_appendFormatted", 2, 2, &obj0, &obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_sword__SWBuf, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWBuf_appendFormatted" "', argument " "1"" of type '" "sword::SWBuf *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWBuf * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SWBuf_appendFormatted" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    try {
      result = (sword::SWBuf *) &(arg1)->appendFormatted((char const *)arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__SWBuf, 0 |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWBuf_appendFormatted(PyObject *self, PyObject *args) {
  PyObject *resultobj;
  PyObject *varargs;
  PyObject *newargs;
  
  newargs = PyTuple_GetSlice(args, 0, 2);
  varargs = PyTuple_GetSlice(args, 2, PyTuple_Size(args));
  resultobj = _wrap_SWBuf_appendFormatted__varargs__(NULL, newargs, varargs);
  SWIG_Py_XDECREF(newargs);
  SWIG_Py_XDECREF(varargs);
  return resultobj;
}


SWIGINTERN PyObject *_wrap_SWBuf_insert__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::SWBuf *arg1 = 0 ;
  unsigned long arg2 ;
  char *arg3 = 0 ;
  unsigned long arg4 ;
  long arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long val2 ;
  int ecode2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  unsigned long val4 ;
  int ecode4 = 0 ;
  long val5 ;
  int ecode5 = 0 ;
  
  (void)self;
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWBuf, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWBuf_insert" "', argument " "1"" of type '" "sword::SWBuf *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWBuf * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SWBuf_insert" "', argument " "2"" of type '" "unsigned long""'");
  } 
  arg2 = static_cast< unsigned long >(val2);
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SWBuf_insert" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  ecode4 = SWIG_AsVal_unsigned_SS_long(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SWBuf_insert" "', argument " "4"" of type '" "unsigned long""'");
  } 
  arg4 = static_cast< unsigned long >(val4);
  ecode5 = SWIG_AsVal_long(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SWBuf_insert" "', argument " "5"" of type '" "long""'");
  } 
  arg5 = static_cast< long >(val5);
  {
    try {
      (arg1)->insert(arg2,(char const *)arg3,arg4,arg5); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return resultobj;
fail:
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWBuf_insert__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::SWBuf *arg1 = 0 ;
  unsigned long arg2 ;
  char *arg3 = 0 ;
  unsigned long arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long val2 ;
  int ecode2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  unsigned long val4 ;
  int ecode4 = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWBuf, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWBuf_insert" "', argument " "1"" of type '" "sword::SWBuf *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWBuf * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SWBuf_insert" "', argument " "2"" of type '" "unsigned long""'");
  } 
  arg2 = static_cast< unsigned long >(val2);
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SWBuf_insert" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  ecode4 = SWIG_AsVal_unsigned_SS_long(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SWBuf_insert" "', argument " "4"" of type '" "unsigned long""'");
  } 
  arg4 = static_cast< unsigned long >(val4);
  {
    try {
      (arg1)->insert(arg2,(char const *)arg3,arg4); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return resultobj;
fail:
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWBuf_insert__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::SWBuf *arg1 = 0 ;
  unsigned long arg2 ;
  char *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long val2 ;
  int ecode2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWBuf, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWBuf_insert" "', argument " "1"" of type '" "sword::SWBuf *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWBuf * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SWBuf_insert" "', argument " "2"" of type '" "unsigned long""'");
  } 
  arg2 = static_cast< unsigned long >(val2);
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SWBuf_insert" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  {
    try {
      (arg1)->insert(arg2,(char const *)arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return resultobj;
fail:
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWBuf_insert__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::SWBuf *arg1 = 0 ;
  unsigned long arg2 ;
  sword::SWBuf *arg3 = 0 ;
  unsigned long arg4 ;
  long arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  unsigned long val4 ;
  int ecode4 = 0 ;
  long val5 ;
  int ecode5 = 0 ;
  
  (void)self;
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWBuf, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWBuf_insert" "', argument " "1"" of type '" "sword::SWBuf *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWBuf * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SWBuf_insert" "', argument " "2"" of type '" "unsigned long""'");
  } 
  arg2 = static_cast< unsigned long >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_sword__SWBuf,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SWBuf_insert" "', argument " "3"" of type '" "sword::SWBuf const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SWBuf_insert" "', argument " "3"" of type '" "sword::SWBuf const &""'"); 
  }
  arg3 = reinterpret_cast< sword::SWBuf * >(argp3);
  ecode4 = SWIG_AsVal_unsigned_SS_long(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SWBuf_insert" "', argument " "4"" of type '" "unsigned long""'");
  } 
  arg4 = static_cast< unsigned long >(val4);
  ecode5 = SWIG_AsVal_long(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SWBuf_insert" "', argument " "5"" of type '" "long""'");
  } 
  arg5 = static_cast< long >(val5);
  {
    try {
      (arg1)->insert(arg2,(sword::SWBuf const &)*arg3,arg4,arg5); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWBuf_insert__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::SWBuf *arg1 = 0 ;
  unsigned long arg2 ;
  sword::SWBuf *arg3 = 0 ;
  unsigned long arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  unsigned long val4 ;
  int ecode4 = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWBuf, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWBuf_insert" "', argument " "1"" of type '" "sword::SWBuf *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWBuf * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SWBuf_insert" "', argument " "2"" of type '" "unsigned long""'");
  } 
  arg2 = static_cast< unsigned long >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_sword__SWBuf,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SWBuf_insert" "', argument " "3"" of type '" "sword::SWBuf const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SWBuf_insert" "', argument " "3"" of type '" "sword::SWBuf const &""'"); 
  }
  arg3 = reinterpret_cast< sword::SWBuf * >(argp3);
  ecode4 = SWIG_AsVal_unsigned_SS_long(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SWBuf_insert" "', argument " "4"" of type '" "unsigned long""'");
  } 
  arg4 = static_cast< unsigned long >(val4);
  {
    try {
      (arg1)->insert(arg2,(sword::SWBuf const &)*arg3,arg4); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWBuf_insert__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::SWBuf *arg1 = 0 ;
  unsigned long arg2 ;
  sword::SWBuf *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWBuf, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWBuf_insert" "', argument " "1"" of type '" "sword::SWBuf *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWBuf * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SWBuf_insert" "', argument " "2"" of type '" "unsigned long""'");
  } 
  arg2 = static_cast< unsigned long >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_sword__SWBuf,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SWBuf_insert" "', argument " "3"" of type '" "sword::SWBuf const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SWBuf_insert" "', argument " "3"" of type '" "sword::SWBuf const &""'"); 
  }
  arg3 = reinterpret_cast< sword::SWBuf * >(argp3);
  {
    try {
      (arg1)->insert(arg2,(sword::SWBuf const &)*arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWBuf_insert__SWIG_6(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::SWBuf *arg1 = 0 ;
  unsigned long arg2 ;
  char arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long val2 ;
  int ecode2 = 0 ;
  char val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWBuf, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWBuf_insert" "', argument " "1"" of type '" "sword::SWBuf *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWBuf * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SWBuf_insert" "', argument " "2"" of type '" "unsigned long""'");
  } 
  arg2 = static_cast< unsigned long >(val2);
  ecode3 = SWIG_AsVal_char(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SWBuf_insert" "', argument " "3"" of type '" "char""'");
  } 
  arg3 = static_cast< char >(val3);
  {
    try {
      (arg1)->insert(arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWBuf_insert(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SWBuf_insert", 0, 5, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__SWBuf, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_long(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_sword__SWBuf, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SWBuf_insert__SWIG_5(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__SWBuf, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_long(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_char(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SWBuf_insert__SWIG_6(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__SWBuf, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_long(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SWBuf_insert__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__SWBuf, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_long(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_sword__SWBuf, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_unsigned_SS_long(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_SWBuf_insert__SWIG_4(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__SWBuf, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_long(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_unsigned_SS_long(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_SWBuf_insert__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__SWBuf, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_long(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_sword__SWBuf, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_unsigned_SS_long(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_long(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_SWBuf_insert__SWIG_3(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__SWBuf, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_long(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_unsigned_SS_long(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_long(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_SWBuf_insert__SWIG_0(self, argc, argv);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SWBuf_insert'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    sword::SWBuf::insert(unsigned long,char const *,unsigned long,long)\n"
    "    sword::SWBuf::insert(unsigned long,char const *,unsigned long)\n"
    "    sword::SWBuf::insert(unsigned long,char const *)\n"
    "    sword::SWBuf::insert(unsigned long,sword::SWBuf const &,unsigned long,long)\n"
    "    sword::SWBuf::insert(unsigned long,sword::SWBuf const &,unsigned long)\n"
    "    sword::SWBuf::insert(unsigned long,sword::SWBuf const &)\n"
    "    sword::SWBuf::insert(unsigned long,char)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SWBuf_getRawData(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWBuf *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWBuf, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWBuf_getRawData" "', argument " "1"" of type '" "sword::SWBuf *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWBuf * >(argp1);
  {
    try {
      result = (char *)(arg1)->getRawData(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWBuf___str__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWBuf *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWBuf, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWBuf___str__" "', argument " "1"" of type '" "sword::SWBuf const *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWBuf * >(argp1);
  {
    try {
      result = (char *)((sword::SWBuf const *)arg1)->operator const char*(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWBuf_trimStart(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWBuf *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  sword::SWBuf *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWBuf, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWBuf_trimStart" "', argument " "1"" of type '" "sword::SWBuf *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWBuf * >(argp1);
  {
    try {
      result = (sword::SWBuf *) &(arg1)->trimStart(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__SWBuf, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWBuf_trimEnd(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWBuf *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  sword::SWBuf *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWBuf, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWBuf_trimEnd" "', argument " "1"" of type '" "sword::SWBuf *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWBuf * >(argp1);
  {
    try {
      result = (sword::SWBuf *) &(arg1)->trimEnd(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__SWBuf, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWBuf_trim(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWBuf *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  sword::SWBuf *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWBuf, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWBuf_trim" "', argument " "1"" of type '" "sword::SWBuf *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWBuf * >(argp1);
  {
    try {
      result = (sword::SWBuf *) &(arg1)->trim(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__SWBuf, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWBuf_stripPrefix__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::SWBuf *arg1 = 0 ;
  char arg2 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  char *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWBuf, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWBuf_stripPrefix" "', argument " "1"" of type '" "sword::SWBuf *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWBuf * >(argp1);
  ecode2 = SWIG_AsVal_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SWBuf_stripPrefix" "', argument " "2"" of type '" "char""'");
  } 
  arg2 = static_cast< char >(val2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SWBuf_stripPrefix" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    try {
      result = (char *)(arg1)->stripPrefix(arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWBuf_stripPrefix__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::SWBuf *arg1 = 0 ;
  char arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char val2 ;
  int ecode2 = 0 ;
  char *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWBuf, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWBuf_stripPrefix" "', argument " "1"" of type '" "sword::SWBuf *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWBuf * >(argp1);
  ecode2 = SWIG_AsVal_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SWBuf_stripPrefix" "', argument " "2"" of type '" "char""'");
  } 
  arg2 = static_cast< char >(val2);
  {
    try {
      result = (char *)(arg1)->stripPrefix(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWBuf_stripPrefix(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SWBuf_stripPrefix", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__SWBuf, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_char(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SWBuf_stripPrefix__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__SWBuf, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_char(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SWBuf_stripPrefix__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SWBuf_stripPrefix'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    sword::SWBuf::stripPrefix(char,bool)\n"
    "    sword::SWBuf::stripPrefix(char)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SWBuf_replaceBytes(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWBuf *arg1 = 0 ;
  char *arg2 = 0 ;
  char arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  char val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  sword::SWBuf *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SWBuf_replaceBytes", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWBuf, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWBuf_replaceBytes" "', argument " "1"" of type '" "sword::SWBuf *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWBuf * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SWBuf_replaceBytes" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  ecode3 = SWIG_AsVal_char(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SWBuf_replaceBytes" "', argument " "3"" of type '" "char""'");
  } 
  arg3 = static_cast< char >(val3);
  {
    try {
      result = (sword::SWBuf *) &(arg1)->replaceBytes((char const *)arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__SWBuf, 0 |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWBuf_startsWith__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::SWBuf *arg1 = 0 ;
  sword::SWBuf *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWBuf, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWBuf_startsWith" "', argument " "1"" of type '" "sword::SWBuf const *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWBuf * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_sword__SWBuf,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SWBuf_startsWith" "', argument " "2"" of type '" "sword::SWBuf const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SWBuf_startsWith" "', argument " "2"" of type '" "sword::SWBuf const &""'"); 
  }
  arg2 = reinterpret_cast< sword::SWBuf * >(argp2);
  {
    try {
      result = (bool)((sword::SWBuf const *)arg1)->startsWith((sword::SWBuf const &)*arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWBuf_toUpper(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWBuf *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  sword::SWBuf *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWBuf, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWBuf_toUpper" "', argument " "1"" of type '" "sword::SWBuf *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWBuf * >(argp1);
  {
    try {
      result = (sword::SWBuf *) &(arg1)->toUpper(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__SWBuf, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWBuf_toLower(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWBuf *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  sword::SWBuf *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWBuf, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWBuf_toLower" "', argument " "1"" of type '" "sword::SWBuf *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWBuf * >(argp1);
  {
    try {
      result = (sword::SWBuf *) &(arg1)->toLower(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__SWBuf, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWBuf_endsWith__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::SWBuf *arg1 = 0 ;
  sword::SWBuf *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWBuf, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWBuf_endsWith" "', argument " "1"" of type '" "sword::SWBuf const *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWBuf * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_sword__SWBuf,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SWBuf_endsWith" "', argument " "2"" of type '" "sword::SWBuf const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SWBuf_endsWith" "', argument " "2"" of type '" "sword::SWBuf const &""'"); 
  }
  arg2 = reinterpret_cast< sword::SWBuf * >(argp2);
  {
    try {
      result = (bool)((sword::SWBuf const *)arg1)->endsWith((sword::SWBuf const &)*arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWBuf_indexOf(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWBuf *arg1 = 0 ;
  sword::SWBuf *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  long result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SWBuf_indexOf", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWBuf, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWBuf_indexOf" "', argument " "1"" of type '" "sword::SWBuf const *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWBuf * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_sword__SWBuf,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SWBuf_indexOf" "', argument " "2"" of type '" "sword::SWBuf const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SWBuf_indexOf" "', argument " "2"" of type '" "sword::SWBuf const &""'"); 
  }
  arg2 = reinterpret_cast< sword::SWBuf * >(argp2);
  {
    try {
      result = (long)((sword::SWBuf const *)arg1)->indexOf((sword::SWBuf const &)*arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_long(static_cast< long >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWBuf_compare__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::SWBuf *arg1 = 0 ;
  sword::SWBuf *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWBuf, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWBuf_compare" "', argument " "1"" of type '" "sword::SWBuf const *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWBuf * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_sword__SWBuf,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SWBuf_compare" "', argument " "2"" of type '" "sword::SWBuf const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SWBuf_compare" "', argument " "2"" of type '" "sword::SWBuf const &""'"); 
  }
  arg2 = reinterpret_cast< sword::SWBuf * >(argp2);
  {
    try {
      result = (int)((sword::SWBuf const *)arg1)->compare((sword::SWBuf const &)*arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWBuf_startsWith__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::SWBuf *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  bool result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWBuf, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWBuf_startsWith" "', argument " "1"" of type '" "sword::SWBuf const *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWBuf * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SWBuf_startsWith" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    try {
      result = (bool)((sword::SWBuf const *)arg1)->startsWith((char const *)arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWBuf_startsWith(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SWBuf_startsWith", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__SWBuf, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_sword__SWBuf, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SWBuf_startsWith__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__SWBuf, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SWBuf_startsWith__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SWBuf_startsWith'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    sword::SWBuf::startsWith(sword::SWBuf const &) const\n"
    "    sword::SWBuf::startsWith(char const *) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SWBuf_endsWith__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::SWBuf *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  bool result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWBuf, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWBuf_endsWith" "', argument " "1"" of type '" "sword::SWBuf const *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWBuf * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SWBuf_endsWith" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    try {
      result = (bool)((sword::SWBuf const *)arg1)->endsWith((char const *)arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWBuf_endsWith(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SWBuf_endsWith", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__SWBuf, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_sword__SWBuf, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SWBuf_endsWith__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__SWBuf, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SWBuf_endsWith__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SWBuf_endsWith'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    sword::SWBuf::endsWith(sword::SWBuf const &) const\n"
    "    sword::SWBuf::endsWith(char const *) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SWBuf_compare__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::SWBuf *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWBuf, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWBuf_compare" "', argument " "1"" of type '" "sword::SWBuf const *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWBuf * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SWBuf_compare" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    try {
      result = (int)((sword::SWBuf const *)arg1)->compare((char const *)arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWBuf_compare(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SWBuf_compare", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__SWBuf, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_sword__SWBuf, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SWBuf_compare__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__SWBuf, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SWBuf_compare__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SWBuf_compare'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    sword::SWBuf::compare(sword::SWBuf const &) const\n"
    "    sword::SWBuf::compare(char const *) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SWBuf_charAt2(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWBuf *arg1 = 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  char result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SWBuf_charAt2", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWBuf, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWBuf_charAt2" "', argument " "1"" of type '" "sword::SWBuf *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWBuf * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SWBuf_charAt2" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  {
    try {
      result = (char)sword_SWBuf_charAt2(arg1,arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_char(static_cast< char >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SWBuf_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_sword__SWBuf, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SWBuf_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_delete_SwigPyIterator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  swig::SwigPyIterator *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SwigPyIterator" "', argument " "1"" of type '" "swig::SwigPyIterator *""'"); 
  }
  arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
  {
    try {
      delete arg1; 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwigPyIterator_value(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  swig::SwigPyIterator *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_value" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'"); 
  }
  arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
  {
    try {
      result = (PyObject *)((swig::SwigPyIterator const *)arg1)->value(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = result;
  if (!resultobj) SWIG_fail;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwigPyIterator_incr__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  swig::SwigPyIterator *arg1 = 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  swig::SwigPyIterator *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_incr" "', argument " "1"" of type '" "swig::SwigPyIterator *""'"); 
  }
  arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwigPyIterator_incr" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  {
    try {
      result = (swig::SwigPyIterator *)(arg1)->incr(SWIG_STD_MOVE(arg2)); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  if (!result) SWIG_fail;
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, 0);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwigPyIterator_incr__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  swig::SwigPyIterator *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_incr" "', argument " "1"" of type '" "swig::SwigPyIterator *""'"); 
  }
  arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
  {
    try {
      result = (swig::SwigPyIterator *)(arg1)->incr(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  if (!result) SWIG_fail;
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, 0);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwigPyIterator_incr(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SwigPyIterator_incr", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__SwigPyIterator, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SwigPyIterator_incr__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__SwigPyIterator, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SwigPyIterator_incr__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SwigPyIterator_incr'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    swig::SwigPyIterator::incr(size_t)\n"
    "    swig::SwigPyIterator::incr()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SwigPyIterator_decr__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  swig::SwigPyIterator *arg1 = 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  swig::SwigPyIterator *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_decr" "', argument " "1"" of type '" "swig::SwigPyIterator *""'"); 
  }
  arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwigPyIterator_decr" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  {
    try {
      result = (swig::SwigPyIterator *)(arg1)->decr(SWIG_STD_MOVE(arg2)); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  if (!result) SWIG_fail;
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, 0);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwigPyIterator_decr__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  swig::SwigPyIterator *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_decr" "', argument " "1"" of type '" "swig::SwigPyIterator *""'"); 
  }
  arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
  {
    try {
      result = (swig::SwigPyIterator *)(arg1)->decr(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  if (!result) SWIG_fail;
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, 0);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwigPyIterator_decr(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SwigPyIterator_decr", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__SwigPyIterator, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SwigPyIterator_decr__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__SwigPyIterator, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SwigPyIterator_decr__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SwigPyIterator_decr'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    swig::SwigPyIterator::decr(size_t)\n"
    "    swig::SwigPyIterator::decr()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SwigPyIterator_distance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  swig::SwigPyIterator *arg1 = 0 ;
  swig::SwigPyIterator *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  ptrdiff_t result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SwigPyIterator_distance", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_distance" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'"); 
  }
  arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_swig__SwigPyIterator,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SwigPyIterator_distance" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SwigPyIterator_distance" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'"); 
  }
  arg2 = reinterpret_cast< swig::SwigPyIterator * >(argp2);
  {
    try {
      try {
        result = ((swig::SwigPyIterator const *)arg1)->distance((swig::SwigPyIterator const &)*arg2);
      } catch(std::invalid_argument &_e) {
        SWIG_Python_Raise(SWIG_NewPointerObj((new std::invalid_argument(static_cast< const std::invalid_argument& >(_e))),SWIGTYPE_p_std__invalid_argument,SWIG_POINTER_OWN), "std::invalid_argument", SWIGTYPE_p_std__invalid_argument); SWIG_fail;
      } 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_ptrdiff_t(static_cast< ptrdiff_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwigPyIterator_equal(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  swig::SwigPyIterator *arg1 = 0 ;
  swig::SwigPyIterator *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SwigPyIterator_equal", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_equal" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'"); 
  }
  arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_swig__SwigPyIterator,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SwigPyIterator_equal" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SwigPyIterator_equal" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'"); 
  }
  arg2 = reinterpret_cast< swig::SwigPyIterator * >(argp2);
  {
    try {
      try {
        result = (bool)((swig::SwigPyIterator const *)arg1)->equal((swig::SwigPyIterator const &)*arg2);
      } catch(std::invalid_argument &_e) {
        SWIG_Python_Raise(SWIG_NewPointerObj((new std::invalid_argument(static_cast< const std::invalid_argument& >(_e))),SWIGTYPE_p_std__invalid_argument,SWIG_POINTER_OWN), "std::invalid_argument", SWIGTYPE_p_std__invalid_argument); SWIG_fail;
      } 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwigPyIterator_copy(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  swig::SwigPyIterator *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  swig::SwigPyIterator *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_copy" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'"); 
  }
  arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
  {
    try {
      result = (swig::SwigPyIterator *)((swig::SwigPyIterator const *)arg1)->copy(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  if (!result) SWIG_fail;
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwigPyIterator_next(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  swig::SwigPyIterator *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_next" "', argument " "1"" of type '" "swig::SwigPyIterator *""'"); 
  }
  arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
  {
    try {
      result = (PyObject *)(arg1)->next(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = result;
  if (!resultobj) SWIG_fail;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwigPyIterator___next__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  swig::SwigPyIterator *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___next__" "', argument " "1"" of type '" "swig::SwigPyIterator *""'"); 
  }
  arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
  {
    try {
      result = (PyObject *)(arg1)->__next__(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = result;
  if (!resultobj) SWIG_fail;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwigPyIterator_previous(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  swig::SwigPyIterator *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_previous" "', argument " "1"" of type '" "swig::SwigPyIterator *""'"); 
  }
  arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
  {
    try {
      result = (PyObject *)(arg1)->previous(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = result;
  if (!resultobj) SWIG_fail;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwigPyIterator_advance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  swig::SwigPyIterator *arg1 = 0 ;
  ptrdiff_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  swig::SwigPyIterator *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SwigPyIterator_advance", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_advance" "', argument " "1"" of type '" "swig::SwigPyIterator *""'"); 
  }
  arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwigPyIterator_advance" "', argument " "2"" of type '" "ptrdiff_t""'");
  } 
  arg2 = static_cast< ptrdiff_t >(val2);
  {
    try {
      result = (swig::SwigPyIterator *)(arg1)->advance(SWIG_STD_MOVE(arg2)); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  if (!result) SWIG_fail;
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, 0);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwigPyIterator___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  swig::SwigPyIterator *arg1 = 0 ;
  swig::SwigPyIterator *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SwigPyIterator___eq__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___eq__" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'"); 
  }
  arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_swig__SwigPyIterator,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SwigPyIterator___eq__" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SwigPyIterator___eq__" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'"); 
  }
  arg2 = reinterpret_cast< swig::SwigPyIterator * >(argp2);
  {
    try {
      result = (bool)((swig::SwigPyIterator const *)arg1)->operator ==((swig::SwigPyIterator const &)*arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SwigPyIterator___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  swig::SwigPyIterator *arg1 = 0 ;
  swig::SwigPyIterator *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SwigPyIterator___ne__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___ne__" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'"); 
  }
  arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_swig__SwigPyIterator,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SwigPyIterator___ne__" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SwigPyIterator___ne__" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'"); 
  }
  arg2 = reinterpret_cast< swig::SwigPyIterator * >(argp2);
  {
    try {
      result = (bool)((swig::SwigPyIterator const *)arg1)->operator !=((swig::SwigPyIterator const &)*arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SwigPyIterator___iadd__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  swig::SwigPyIterator *arg1 = 0 ;
  ptrdiff_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  swig::SwigPyIterator *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SwigPyIterator___iadd__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___iadd__" "', argument " "1"" of type '" "swig::SwigPyIterator *""'"); 
  }
  arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwigPyIterator___iadd__" "', argument " "2"" of type '" "ptrdiff_t""'");
  } 
  arg2 = static_cast< ptrdiff_t >(val2);
  {
    try {
      result = (swig::SwigPyIterator *) &(arg1)->operator +=(SWIG_STD_MOVE(arg2)); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  if (PyErr_Occurred()) SWIG_fail;
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwigPyIterator___isub__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  swig::SwigPyIterator *arg1 = 0 ;
  ptrdiff_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  swig::SwigPyIterator *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SwigPyIterator___isub__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___isub__" "', argument " "1"" of type '" "swig::SwigPyIterator *""'"); 
  }
  arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwigPyIterator___isub__" "', argument " "2"" of type '" "ptrdiff_t""'");
  } 
  arg2 = static_cast< ptrdiff_t >(val2);
  {
    try {
      result = (swig::SwigPyIterator *) &(arg1)->operator -=(SWIG_STD_MOVE(arg2)); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  if (PyErr_Occurred()) SWIG_fail;
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwigPyIterator___add__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  swig::SwigPyIterator *arg1 = 0 ;
  ptrdiff_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  swig::SwigPyIterator *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SwigPyIterator___add__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___add__" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'"); 
  }
  arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwigPyIterator___add__" "', argument " "2"" of type '" "ptrdiff_t""'");
  } 
  arg2 = static_cast< ptrdiff_t >(val2);
  {
    try {
      result = (swig::SwigPyIterator *)((swig::SwigPyIterator const *)arg1)->operator +(SWIG_STD_MOVE(arg2)); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  if (!result) SWIG_fail;
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN);
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SwigPyIterator___sub____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  swig::SwigPyIterator *arg1 = 0 ;
  ptrdiff_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  swig::SwigPyIterator *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___sub__" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'"); 
  }
  arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwigPyIterator___sub__" "', argument " "2"" of type '" "ptrdiff_t""'");
  } 
  arg2 = static_cast< ptrdiff_t >(val2);
  {
    try {
      result = (swig::SwigPyIterator *)((swig::SwigPyIterator const *)arg1)->operator -(SWIG_STD_MOVE(arg2)); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  if (!result) SWIG_fail;
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN);
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SwigPyIterator___sub____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  swig::SwigPyIterator *arg1 = 0 ;
  swig::SwigPyIterator *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  ptrdiff_t result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___sub__" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'"); 
  }
  arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_swig__SwigPyIterator,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SwigPyIterator___sub__" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SwigPyIterator___sub__" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'"); 
  }
  arg2 = reinterpret_cast< swig::SwigPyIterator * >(argp2);
  {
    try {
      result = ((swig::SwigPyIterator const *)arg1)->operator -((swig::SwigPyIterator const &)*arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_ptrdiff_t(static_cast< ptrdiff_t >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SwigPyIterator___sub__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SwigPyIterator___sub__", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__SwigPyIterator, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SwigPyIterator___sub____SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__SwigPyIterator, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SwigPyIterator___sub____SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *SwigPyIterator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_swig__SwigPyIterator, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_AttributeValueMap__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::less< sword::SWBuf > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::map< sword::SWBuf,sword::SWBuf > *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_std__lessT_sword__SWBuf_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_AttributeValueMap" "', argument " "1"" of type '" "std::less< sword::SWBuf > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_AttributeValueMap" "', argument " "1"" of type '" "std::less< sword::SWBuf > const &""'"); 
  }
  arg1 = reinterpret_cast< std::less< sword::SWBuf > * >(argp1);
  {
    try {
      result = (std::map< sword::SWBuf,sword::SWBuf > *)new std::map< sword::SWBuf,sword::SWBuf >((std::less< sword::SWBuf > const &)*arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__mapT_sword__SWBuf_sword__SWBuf_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_AttributeValueMap_iterator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::map< sword::SWBuf,sword::SWBuf > *arg1 = 0 ;
  PyObject **arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  swig::SwigPyIterator *result = 0 ;
  
  arg2 = &swig_obj[0];
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_sword__SWBuf_sword__SWBuf_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AttributeValueMap_iterator" "', argument " "1"" of type '" "std::map< sword::SWBuf,sword::SWBuf > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< sword::SWBuf,sword::SWBuf > * >(argp1);
  {
    try {
      result = (swig::SwigPyIterator *)std_map_Sl_sword_SWBuf_Sc_sword_SWBuf_Sg__iterator(arg1,arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  if (!result) SWIG_fail;
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_AttributeValueMap___nonzero__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::map< sword::SWBuf,sword::SWBuf > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_sword__SWBuf_sword__SWBuf_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AttributeValueMap___nonzero__" "', argument " "1"" of type '" "std::map< sword::SWBuf,sword::SWBuf > const *""'"); 
  }
  arg1 = reinterpret_cast< std::map< sword::SWBuf,sword::SWBuf > * >(argp1);
  {
    try {
      result = (bool)std_map_Sl_sword_SWBuf_Sc_sword_SWBuf_Sg____nonzero__((std::map< sword::SWBuf,sword::SWBuf > const *)arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_AttributeValueMap___bool__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::map< sword::SWBuf,sword::SWBuf > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_sword__SWBuf_sword__SWBuf_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AttributeValueMap___bool__" "', argument " "1"" of type '" "std::map< sword::SWBuf,sword::SWBuf > const *""'"); 
  }
  arg1 = reinterpret_cast< std::map< sword::SWBuf,sword::SWBuf > * >(argp1);
  {
    try {
      result = (bool)std_map_Sl_sword_SWBuf_Sc_sword_SWBuf_Sg____bool__((std::map< sword::SWBuf,sword::SWBuf > const *)arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_AttributeValueMap___len__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::map< sword::SWBuf,sword::SWBuf > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::map< sword::SWBuf,sword::SWBuf >::size_type result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_sword__SWBuf_sword__SWBuf_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AttributeValueMap___len__" "', argument " "1"" of type '" "std::map< sword::SWBuf,sword::SWBuf > const *""'"); 
  }
  arg1 = reinterpret_cast< std::map< sword::SWBuf,sword::SWBuf > * >(argp1);
  {
    try {
      result = std_map_Sl_sword_SWBuf_Sc_sword_SWBuf_Sg____len__((std::map< sword::SWBuf,sword::SWBuf > const *)arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_AttributeValueMap___getitem__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::map< sword::SWBuf,sword::SWBuf > *arg1 = 0 ;
  std::map< sword::SWBuf,sword::SWBuf >::key_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  std::map< sword::SWBuf,sword::SWBuf >::mapped_type *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "AttributeValueMap___getitem__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_sword__SWBuf_sword__SWBuf_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AttributeValueMap___getitem__" "', argument " "1"" of type '" "std::map< sword::SWBuf,sword::SWBuf > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< sword::SWBuf,sword::SWBuf > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_sword__SWBuf,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "AttributeValueMap___getitem__" "', argument " "2"" of type '" "std::map< sword::SWBuf,sword::SWBuf >::key_type const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "AttributeValueMap___getitem__" "', argument " "2"" of type '" "std::map< sword::SWBuf,sword::SWBuf >::key_type const &""'"); 
  }
  arg2 = reinterpret_cast< std::map< sword::SWBuf,sword::SWBuf >::key_type * >(argp2);
  {
    try {
      try {
        result = (std::map< sword::SWBuf,sword::SWBuf >::mapped_type *) &std_map_Sl_sword_SWBuf_Sc_sword_SWBuf_Sg____getitem__(arg1,(sword::SWBuf const &)*arg2);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__SWBuf, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_AttributeValueMap___delitem__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::map< sword::SWBuf,sword::SWBuf > *arg1 = 0 ;
  std::map< sword::SWBuf,sword::SWBuf >::key_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "AttributeValueMap___delitem__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_sword__SWBuf_sword__SWBuf_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AttributeValueMap___delitem__" "', argument " "1"" of type '" "std::map< sword::SWBuf,sword::SWBuf > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< sword::SWBuf,sword::SWBuf > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_sword__SWBuf,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "AttributeValueMap___delitem__" "', argument " "2"" of type '" "std::map< sword::SWBuf,sword::SWBuf >::key_type const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "AttributeValueMap___delitem__" "', argument " "2"" of type '" "std::map< sword::SWBuf,sword::SWBuf >::key_type const &""'"); 
  }
  arg2 = reinterpret_cast< std::map< sword::SWBuf,sword::SWBuf >::key_type * >(argp2);
  {
    try {
      try {
        std_map_Sl_sword_SWBuf_Sc_sword_SWBuf_Sg____delitem__(arg1,(sword::SWBuf const &)*arg2);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_AttributeValueMap_has_key(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::map< sword::SWBuf,sword::SWBuf > *arg1 = 0 ;
  std::map< sword::SWBuf,sword::SWBuf >::key_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "AttributeValueMap_has_key", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_sword__SWBuf_sword__SWBuf_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AttributeValueMap_has_key" "', argument " "1"" of type '" "std::map< sword::SWBuf,sword::SWBuf > const *""'"); 
  }
  arg1 = reinterpret_cast< std::map< sword::SWBuf,sword::SWBuf > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_sword__SWBuf,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "AttributeValueMap_has_key" "', argument " "2"" of type '" "std::map< sword::SWBuf,sword::SWBuf >::key_type const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "AttributeValueMap_has_key" "', argument " "2"" of type '" "std::map< sword::SWBuf,sword::SWBuf >::key_type const &""'"); 
  }
  arg2 = reinterpret_cast< std::map< sword::SWBuf,sword::SWBuf >::key_type * >(argp2);
  {
    try {
      result = (bool)std_map_Sl_sword_SWBuf_Sc_sword_SWBuf_Sg__has_key((std::map< sword::SWBuf,sword::SWBuf > const *)arg1,(sword::SWBuf const &)*arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_AttributeValueMap_keys(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::map< sword::SWBuf,sword::SWBuf > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_sword__SWBuf_sword__SWBuf_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AttributeValueMap_keys" "', argument " "1"" of type '" "std::map< sword::SWBuf,sword::SWBuf > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< sword::SWBuf,sword::SWBuf > * >(argp1);
  {
    try {
      result = (PyObject *)std_map_Sl_sword_SWBuf_Sc_sword_SWBuf_Sg__keys(arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = result;
  if (!resultobj) SWIG_fail;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_AttributeValueMap_values(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::map< sword::SWBuf,sword::SWBuf > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_sword__SWBuf_sword__SWBuf_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AttributeValueMap_values" "', argument " "1"" of type '" "std::map< sword::SWBuf,sword::SWBuf > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< sword::SWBuf,sword::SWBuf > * >(argp1);
  {
    try {
      result = (PyObject *)std_map_Sl_sword_SWBuf_Sc_sword_SWBuf_Sg__values(arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = result;
  if (!resultobj) SWIG_fail;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_AttributeValueMap_items(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::map< sword::SWBuf,sword::SWBuf > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_sword__SWBuf_sword__SWBuf_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AttributeValueMap_items" "', argument " "1"" of type '" "std::map< sword::SWBuf,sword::SWBuf > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< sword::SWBuf,sword::SWBuf > * >(argp1);
  {
    try {
      result = (PyObject *)std_map_Sl_sword_SWBuf_Sc_sword_SWBuf_Sg__items(arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = result;
  if (!resultobj) SWIG_fail;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_AttributeValueMap___contains__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::map< sword::SWBuf,sword::SWBuf > *arg1 = 0 ;
  std::map< sword::SWBuf,sword::SWBuf >::key_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "AttributeValueMap___contains__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_sword__SWBuf_sword__SWBuf_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AttributeValueMap___contains__" "', argument " "1"" of type '" "std::map< sword::SWBuf,sword::SWBuf > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< sword::SWBuf,sword::SWBuf > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_sword__SWBuf,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "AttributeValueMap___contains__" "', argument " "2"" of type '" "std::map< sword::SWBuf,sword::SWBuf >::key_type const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "AttributeValueMap___contains__" "', argument " "2"" of type '" "std::map< sword::SWBuf,sword::SWBuf >::key_type const &""'"); 
  }
  arg2 = reinterpret_cast< std::map< sword::SWBuf,sword::SWBuf >::key_type * >(argp2);
  {
    try {
      result = (bool)std_map_Sl_sword_SWBuf_Sc_sword_SWBuf_Sg____contains__(arg1,(sword::SWBuf const &)*arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_AttributeValueMap_key_iterator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::map< sword::SWBuf,sword::SWBuf > *arg1 = 0 ;
  PyObject **arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  swig::SwigPyIterator *result = 0 ;
  
  arg2 = &swig_obj[0];
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_sword__SWBuf_sword__SWBuf_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AttributeValueMap_key_iterator" "', argument " "1"" of type '" "std::map< sword::SWBuf,sword::SWBuf > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< sword::SWBuf,sword::SWBuf > * >(argp1);
  {
    try {
      result = (swig::SwigPyIterator *)std_map_Sl_sword_SWBuf_Sc_sword_SWBuf_Sg__key_iterator(arg1,arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  if (!result) SWIG_fail;
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_AttributeValueMap_value_iterator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::map< sword::SWBuf,sword::SWBuf > *arg1 = 0 ;
  PyObject **arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  swig::SwigPyIterator *result = 0 ;
  
  arg2 = &swig_obj[0];
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_sword__SWBuf_sword__SWBuf_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AttributeValueMap_value_iterator" "', argument " "1"" of type '" "std::map< sword::SWBuf,sword::SWBuf > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< sword::SWBuf,sword::SWBuf > * >(argp1);
  {
    try {
      result = (swig::SwigPyIterator *)std_map_Sl_sword_SWBuf_Sc_sword_SWBuf_Sg__value_iterator(arg1,arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  if (!result) SWIG_fail;
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_AttributeValueMap___setitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::map< sword::SWBuf,sword::SWBuf > *arg1 = 0 ;
  std::map< sword::SWBuf,sword::SWBuf >::key_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_sword__SWBuf_sword__SWBuf_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AttributeValueMap___setitem__" "', argument " "1"" of type '" "std::map< sword::SWBuf,sword::SWBuf > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< sword::SWBuf,sword::SWBuf > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_sword__SWBuf,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "AttributeValueMap___setitem__" "', argument " "2"" of type '" "std::map< sword::SWBuf,sword::SWBuf >::key_type const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "AttributeValueMap___setitem__" "', argument " "2"" of type '" "std::map< sword::SWBuf,sword::SWBuf >::key_type const &""'"); 
  }
  arg2 = reinterpret_cast< std::map< sword::SWBuf,sword::SWBuf >::key_type * >(argp2);
  {
    try {
      std_map_Sl_sword_SWBuf_Sc_sword_SWBuf_Sg____setitem____SWIG_0(arg1,(sword::SWBuf const &)*arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_AttributeValueMap___setitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::map< sword::SWBuf,sword::SWBuf > *arg1 = 0 ;
  std::map< sword::SWBuf,sword::SWBuf >::key_type *arg2 = 0 ;
  std::map< sword::SWBuf,sword::SWBuf >::mapped_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_sword__SWBuf_sword__SWBuf_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AttributeValueMap___setitem__" "', argument " "1"" of type '" "std::map< sword::SWBuf,sword::SWBuf > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< sword::SWBuf,sword::SWBuf > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_sword__SWBuf,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "AttributeValueMap___setitem__" "', argument " "2"" of type '" "std::map< sword::SWBuf,sword::SWBuf >::key_type const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "AttributeValueMap___setitem__" "', argument " "2"" of type '" "std::map< sword::SWBuf,sword::SWBuf >::key_type const &""'"); 
  }
  arg2 = reinterpret_cast< std::map< sword::SWBuf,sword::SWBuf >::key_type * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_sword__SWBuf,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "AttributeValueMap___setitem__" "', argument " "3"" of type '" "std::map< sword::SWBuf,sword::SWBuf >::mapped_type const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "AttributeValueMap___setitem__" "', argument " "3"" of type '" "std::map< sword::SWBuf,sword::SWBuf >::mapped_type const &""'"); 
  }
  arg3 = reinterpret_cast< std::map< sword::SWBuf,sword::SWBuf >::mapped_type * >(argp3);
  {
    try {
      try {
        std_map_Sl_sword_SWBuf_Sc_sword_SWBuf_Sg____setitem____SWIG_1(arg1,(sword::SWBuf const &)*arg2,(sword::SWBuf const &)*arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_AttributeValueMap___setitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "AttributeValueMap___setitem__", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_sword__SWBuf, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_AttributeValueMap___setitem____SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_sword__SWBuf, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_sword__SWBuf, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_AttributeValueMap___setitem____SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'AttributeValueMap___setitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::map< sword::SWBuf,sword::SWBuf >::__setitem__(std::map< sword::SWBuf,sword::SWBuf >::key_type const &)\n"
    "    std::map< sword::SWBuf,sword::SWBuf >::__setitem__(std::map< sword::SWBuf,sword::SWBuf >::key_type const &,std::map< sword::SWBuf,sword::SWBuf >::mapped_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_AttributeValueMap_asdict(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::map< sword::SWBuf,sword::SWBuf > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_sword__SWBuf_sword__SWBuf_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AttributeValueMap_asdict" "', argument " "1"" of type '" "std::map< sword::SWBuf,sword::SWBuf > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< sword::SWBuf,sword::SWBuf > * >(argp1);
  {
    try {
      result = (PyObject *)std_map_Sl_sword_SWBuf_Sc_sword_SWBuf_Sg__asdict(arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = result;
  if (!resultobj) SWIG_fail;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AttributeValueMap__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  std::map< sword::SWBuf,sword::SWBuf > *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (std::map< sword::SWBuf,sword::SWBuf > *)new std::map< sword::SWBuf,sword::SWBuf >(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__mapT_sword__SWBuf_sword__SWBuf_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AttributeValueMap__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::map< sword::SWBuf,sword::SWBuf > *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  std::map< sword::SWBuf,sword::SWBuf > *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > *ptr = (std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_AttributeValueMap" "', argument " "1"" of type '" "std::map< sword::SWBuf,sword::SWBuf > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_AttributeValueMap" "', argument " "1"" of type '" "std::map< sword::SWBuf,sword::SWBuf > const &""'"); 
    }
    arg1 = ptr;
  }
  {
    try {
      result = (std::map< sword::SWBuf,sword::SWBuf > *)new std::map< sword::SWBuf,sword::SWBuf >((std::map< sword::SWBuf,sword::SWBuf > const &)*arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__mapT_sword__SWBuf_sword__SWBuf_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AttributeValueMap(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_AttributeValueMap", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_AttributeValueMap__SWIG_1(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_std__lessT_sword__SWBuf_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_AttributeValueMap__SWIG_0(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_AttributeValueMap__SWIG_2(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_AttributeValueMap'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::map< sword::SWBuf,sword::SWBuf >::map(std::less< sword::SWBuf > const &)\n"
    "    std::map< sword::SWBuf,sword::SWBuf >::map()\n"
    "    std::map< sword::SWBuf,sword::SWBuf >::map(std::map< sword::SWBuf,sword::SWBuf > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_AttributeValueMap_empty(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::map< sword::SWBuf,sword::SWBuf > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_sword__SWBuf_sword__SWBuf_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AttributeValueMap_empty" "', argument " "1"" of type '" "std::map< sword::SWBuf,sword::SWBuf > const *""'"); 
  }
  arg1 = reinterpret_cast< std::map< sword::SWBuf,sword::SWBuf > * >(argp1);
  {
    try {
      result = (bool)((std::map< sword::SWBuf,sword::SWBuf > const *)arg1)->empty(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_AttributeValueMap_size(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::map< sword::SWBuf,sword::SWBuf > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::map< sword::SWBuf,sword::SWBuf >::size_type result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_sword__SWBuf_sword__SWBuf_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AttributeValueMap_size" "', argument " "1"" of type '" "std::map< sword::SWBuf,sword::SWBuf > const *""'"); 
  }
  arg1 = reinterpret_cast< std::map< sword::SWBuf,sword::SWBuf > * >(argp1);
  {
    try {
      result = ((std::map< sword::SWBuf,sword::SWBuf > const *)arg1)->size(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_AttributeValueMap_swap(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::map< sword::SWBuf,sword::SWBuf > *arg1 = 0 ;
  std::map< sword::SWBuf,sword::SWBuf > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "AttributeValueMap_swap", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_sword__SWBuf_sword__SWBuf_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AttributeValueMap_swap" "', argument " "1"" of type '" "std::map< sword::SWBuf,sword::SWBuf > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< sword::SWBuf,sword::SWBuf > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__mapT_sword__SWBuf_sword__SWBuf_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "AttributeValueMap_swap" "', argument " "2"" of type '" "std::map< sword::SWBuf,sword::SWBuf > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "AttributeValueMap_swap" "', argument " "2"" of type '" "std::map< sword::SWBuf,sword::SWBuf > &""'"); 
  }
  arg2 = reinterpret_cast< std::map< sword::SWBuf,sword::SWBuf > * >(argp2);
  {
    try {
      (arg1)->swap(*arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_AttributeValueMap_begin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::map< sword::SWBuf,sword::SWBuf > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::map< sword::SWBuf,sword::SWBuf >::iterator result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_sword__SWBuf_sword__SWBuf_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AttributeValueMap_begin" "', argument " "1"" of type '" "std::map< sword::SWBuf,sword::SWBuf > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< sword::SWBuf,sword::SWBuf > * >(argp1);
  {
    try {
      result = (arg1)->begin(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::map< sword::SWBuf,sword::SWBuf >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_AttributeValueMap_end(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::map< sword::SWBuf,sword::SWBuf > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::map< sword::SWBuf,sword::SWBuf >::iterator result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_sword__SWBuf_sword__SWBuf_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AttributeValueMap_end" "', argument " "1"" of type '" "std::map< sword::SWBuf,sword::SWBuf > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< sword::SWBuf,sword::SWBuf > * >(argp1);
  {
    try {
      result = (arg1)->end(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::map< sword::SWBuf,sword::SWBuf >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_AttributeValueMap_rbegin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::map< sword::SWBuf,sword::SWBuf > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::map< sword::SWBuf,sword::SWBuf >::reverse_iterator result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_sword__SWBuf_sword__SWBuf_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AttributeValueMap_rbegin" "', argument " "1"" of type '" "std::map< sword::SWBuf,sword::SWBuf > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< sword::SWBuf,sword::SWBuf > * >(argp1);
  {
    try {
      result = (arg1)->rbegin(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::map< sword::SWBuf,sword::SWBuf >::reverse_iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_AttributeValueMap_rend(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::map< sword::SWBuf,sword::SWBuf > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::map< sword::SWBuf,sword::SWBuf >::reverse_iterator result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_sword__SWBuf_sword__SWBuf_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AttributeValueMap_rend" "', argument " "1"" of type '" "std::map< sword::SWBuf,sword::SWBuf > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< sword::SWBuf,sword::SWBuf > * >(argp1);
  {
    try {
      result = (arg1)->rend(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::map< sword::SWBuf,sword::SWBuf >::reverse_iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_AttributeValueMap_clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::map< sword::SWBuf,sword::SWBuf > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_sword__SWBuf_sword__SWBuf_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AttributeValueMap_clear" "', argument " "1"" of type '" "std::map< sword::SWBuf,sword::SWBuf > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< sword::SWBuf,sword::SWBuf > * >(argp1);
  {
    try {
      (arg1)->clear(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_AttributeValueMap_get_allocator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::map< sword::SWBuf,sword::SWBuf > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_sword__SWBuf_sword__SWBuf_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AttributeValueMap_get_allocator" "', argument " "1"" of type '" "std::map< sword::SWBuf,sword::SWBuf > const *""'"); 
  }
  arg1 = reinterpret_cast< std::map< sword::SWBuf,sword::SWBuf > * >(argp1);
  {
    try {
      result = ((std::map< sword::SWBuf,sword::SWBuf > const *)arg1)->get_allocator(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj((new std::map< sword::SWBuf,sword::SWBuf >::allocator_type(result)), SWIGTYPE_p_std__allocatorT_std__pairT_sword__SWBuf_const_sword__SWBuf_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_AttributeValueMap_erase__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::map< sword::SWBuf,sword::SWBuf > *arg1 = 0 ;
  std::map< sword::SWBuf,sword::SWBuf >::key_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  std::map< sword::SWBuf,sword::SWBuf >::size_type result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_sword__SWBuf_sword__SWBuf_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AttributeValueMap_erase" "', argument " "1"" of type '" "std::map< sword::SWBuf,sword::SWBuf > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< sword::SWBuf,sword::SWBuf > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_sword__SWBuf,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "AttributeValueMap_erase" "', argument " "2"" of type '" "std::map< sword::SWBuf,sword::SWBuf >::key_type const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "AttributeValueMap_erase" "', argument " "2"" of type '" "std::map< sword::SWBuf,sword::SWBuf >::key_type const &""'"); 
  }
  arg2 = reinterpret_cast< std::map< sword::SWBuf,sword::SWBuf >::key_type * >(argp2);
  {
    try {
      result = (arg1)->erase((std::map< sword::SWBuf,sword::SWBuf >::key_type const &)*arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_AttributeValueMap_count(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::map< sword::SWBuf,sword::SWBuf > *arg1 = 0 ;
  std::map< sword::SWBuf,sword::SWBuf >::key_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  std::map< sword::SWBuf,sword::SWBuf >::size_type result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "AttributeValueMap_count", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_sword__SWBuf_sword__SWBuf_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AttributeValueMap_count" "', argument " "1"" of type '" "std::map< sword::SWBuf,sword::SWBuf > const *""'"); 
  }
  arg1 = reinterpret_cast< std::map< sword::SWBuf,sword::SWBuf > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_sword__SWBuf,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "AttributeValueMap_count" "', argument " "2"" of type '" "std::map< sword::SWBuf,sword::SWBuf >::key_type const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "AttributeValueMap_count" "', argument " "2"" of type '" "std::map< sword::SWBuf,sword::SWBuf >::key_type const &""'"); 
  }
  arg2 = reinterpret_cast< std::map< sword::SWBuf,sword::SWBuf >::key_type * >(argp2);
  {
    try {
      result = ((std::map< sword::SWBuf,sword::SWBuf > const *)arg1)->count((std::map< sword::SWBuf,sword::SWBuf >::key_type const &)*arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_AttributeValueMap_erase__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::map< sword::SWBuf,sword::SWBuf > *arg1 = 0 ;
  std::map< sword::SWBuf,sword::SWBuf >::iterator arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_sword__SWBuf_sword__SWBuf_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AttributeValueMap_erase" "', argument " "1"" of type '" "std::map< sword::SWBuf,sword::SWBuf > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< sword::SWBuf,sword::SWBuf > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "AttributeValueMap_erase" "', argument " "2"" of type '" "std::map< sword::SWBuf,sword::SWBuf >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::map< sword::SWBuf,sword::SWBuf >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::map< sword::SWBuf,sword::SWBuf >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "AttributeValueMap_erase" "', argument " "2"" of type '" "std::map< sword::SWBuf,sword::SWBuf >::iterator""'");
    }
  }
  {
    try {
      std_map_Sl_sword_SWBuf_Sc_sword_SWBuf_Sg__erase__SWIG_1(arg1,SWIG_STD_MOVE(arg2)); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_AttributeValueMap_erase__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::map< sword::SWBuf,sword::SWBuf > *arg1 = 0 ;
  std::map< sword::SWBuf,sword::SWBuf >::iterator arg2 ;
  std::map< sword::SWBuf,sword::SWBuf >::iterator arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  swig::SwigPyIterator *iter3 = 0 ;
  int res3 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_sword__SWBuf_sword__SWBuf_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AttributeValueMap_erase" "', argument " "1"" of type '" "std::map< sword::SWBuf,sword::SWBuf > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< sword::SWBuf,sword::SWBuf > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "AttributeValueMap_erase" "', argument " "2"" of type '" "std::map< sword::SWBuf,sword::SWBuf >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::map< sword::SWBuf,sword::SWBuf >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::map< sword::SWBuf,sword::SWBuf >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "AttributeValueMap_erase" "', argument " "2"" of type '" "std::map< sword::SWBuf,sword::SWBuf >::iterator""'");
    }
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], SWIG_as_voidptrptr(&iter3), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res3) || !iter3) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "AttributeValueMap_erase" "', argument " "3"" of type '" "std::map< sword::SWBuf,sword::SWBuf >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::map< sword::SWBuf,sword::SWBuf >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::map< sword::SWBuf,sword::SWBuf >::iterator > *>(iter3);
    if (iter_t) {
      arg3 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "AttributeValueMap_erase" "', argument " "3"" of type '" "std::map< sword::SWBuf,sword::SWBuf >::iterator""'");
    }
  }
  {
    try {
      std_map_Sl_sword_SWBuf_Sc_sword_SWBuf_Sg__erase__SWIG_2(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3)); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_AttributeValueMap_erase(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "AttributeValueMap_erase", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_sword__SWBuf, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_AttributeValueMap_erase__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::map< sword::SWBuf,sword::SWBuf >::iterator > *>(iter) != 0));
      if (_v) {
        return _wrap_AttributeValueMap_erase__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::map< sword::SWBuf,sword::SWBuf >::iterator > *>(iter) != 0));
      if (_v) {
        swig::SwigPyIterator *iter = 0;
        int res = SWIG_ConvertPtr(argv[2], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
        _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::map< sword::SWBuf,sword::SWBuf >::iterator > *>(iter) != 0));
        if (_v) {
          return _wrap_AttributeValueMap_erase__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'AttributeValueMap_erase'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::map< sword::SWBuf,sword::SWBuf >::erase(std::map< sword::SWBuf,sword::SWBuf >::key_type const &)\n"
    "    std::map< sword::SWBuf,sword::SWBuf >::erase(std::map< sword::SWBuf,sword::SWBuf >::iterator)\n"
    "    std::map< sword::SWBuf,sword::SWBuf >::erase(std::map< sword::SWBuf,sword::SWBuf >::iterator,std::map< sword::SWBuf,sword::SWBuf >::iterator)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_AttributeValueMap_find(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::map< sword::SWBuf,sword::SWBuf > *arg1 = 0 ;
  std::map< sword::SWBuf,sword::SWBuf >::key_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  std::map< sword::SWBuf,sword::SWBuf >::iterator result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "AttributeValueMap_find", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_sword__SWBuf_sword__SWBuf_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AttributeValueMap_find" "', argument " "1"" of type '" "std::map< sword::SWBuf,sword::SWBuf > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< sword::SWBuf,sword::SWBuf > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_sword__SWBuf,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "AttributeValueMap_find" "', argument " "2"" of type '" "std::map< sword::SWBuf,sword::SWBuf >::key_type const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "AttributeValueMap_find" "', argument " "2"" of type '" "std::map< sword::SWBuf,sword::SWBuf >::key_type const &""'"); 
  }
  arg2 = reinterpret_cast< std::map< sword::SWBuf,sword::SWBuf >::key_type * >(argp2);
  {
    try {
      result = (arg1)->find((std::map< sword::SWBuf,sword::SWBuf >::key_type const &)*arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::map< sword::SWBuf,sword::SWBuf >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_AttributeValueMap_lower_bound(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::map< sword::SWBuf,sword::SWBuf > *arg1 = 0 ;
  std::map< sword::SWBuf,sword::SWBuf >::key_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  std::map< sword::SWBuf,sword::SWBuf >::iterator result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "AttributeValueMap_lower_bound", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_sword__SWBuf_sword__SWBuf_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AttributeValueMap_lower_bound" "', argument " "1"" of type '" "std::map< sword::SWBuf,sword::SWBuf > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< sword::SWBuf,sword::SWBuf > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_sword__SWBuf,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "AttributeValueMap_lower_bound" "', argument " "2"" of type '" "std::map< sword::SWBuf,sword::SWBuf >::key_type const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "AttributeValueMap_lower_bound" "', argument " "2"" of type '" "std::map< sword::SWBuf,sword::SWBuf >::key_type const &""'"); 
  }
  arg2 = reinterpret_cast< std::map< sword::SWBuf,sword::SWBuf >::key_type * >(argp2);
  {
    try {
      result = (arg1)->lower_bound((std::map< sword::SWBuf,sword::SWBuf >::key_type const &)*arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::map< sword::SWBuf,sword::SWBuf >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_AttributeValueMap_upper_bound(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::map< sword::SWBuf,sword::SWBuf > *arg1 = 0 ;
  std::map< sword::SWBuf,sword::SWBuf >::key_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  std::map< sword::SWBuf,sword::SWBuf >::iterator result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "AttributeValueMap_upper_bound", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_sword__SWBuf_sword__SWBuf_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AttributeValueMap_upper_bound" "', argument " "1"" of type '" "std::map< sword::SWBuf,sword::SWBuf > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< sword::SWBuf,sword::SWBuf > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_sword__SWBuf,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "AttributeValueMap_upper_bound" "', argument " "2"" of type '" "std::map< sword::SWBuf,sword::SWBuf >::key_type const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "AttributeValueMap_upper_bound" "', argument " "2"" of type '" "std::map< sword::SWBuf,sword::SWBuf >::key_type const &""'"); 
  }
  arg2 = reinterpret_cast< std::map< sword::SWBuf,sword::SWBuf >::key_type * >(argp2);
  {
    try {
      result = (arg1)->upper_bound((std::map< sword::SWBuf,sword::SWBuf >::key_type const &)*arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::map< sword::SWBuf,sword::SWBuf >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_AttributeValueMap(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::map< sword::SWBuf,sword::SWBuf > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_sword__SWBuf_sword__SWBuf_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AttributeValueMap" "', argument " "1"" of type '" "std::map< sword::SWBuf,sword::SWBuf > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< sword::SWBuf,sword::SWBuf > * >(argp1);
  {
    try {
      delete arg1; 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *AttributeValueMap_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__mapT_sword__SWBuf_sword__SWBuf_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *AttributeValueMap_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_AttributeListMap__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::less< sword::SWBuf > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::map< sword::SWBuf,AttributeValueMap > *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_std__lessT_sword__SWBuf_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_AttributeListMap" "', argument " "1"" of type '" "std::less< sword::SWBuf > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_AttributeListMap" "', argument " "1"" of type '" "std::less< sword::SWBuf > const &""'"); 
  }
  arg1 = reinterpret_cast< std::less< sword::SWBuf > * >(argp1);
  {
    try {
      result = (std::map< sword::SWBuf,AttributeValueMap > *)new std::map< sword::SWBuf,AttributeValueMap >((std::less< sword::SWBuf > const &)*arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__mapT_sword__SWBuf_AttributeValueMap_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_AttributeListMap_iterator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::map< sword::SWBuf,AttributeValueMap > *arg1 = 0 ;
  PyObject **arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  swig::SwigPyIterator *result = 0 ;
  
  arg2 = &swig_obj[0];
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_sword__SWBuf_AttributeValueMap_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AttributeListMap_iterator" "', argument " "1"" of type '" "std::map< sword::SWBuf,AttributeValueMap > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< sword::SWBuf,AttributeValueMap > * >(argp1);
  {
    try {
      result = (swig::SwigPyIterator *)std_map_Sl_sword_SWBuf_Sc_AttributeValueMap_Sg__iterator(arg1,arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  if (!result) SWIG_fail;
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_AttributeListMap___nonzero__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::map< sword::SWBuf,AttributeValueMap > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_sword__SWBuf_AttributeValueMap_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AttributeListMap___nonzero__" "', argument " "1"" of type '" "std::map< sword::SWBuf,AttributeValueMap > const *""'"); 
  }
  arg1 = reinterpret_cast< std::map< sword::SWBuf,AttributeValueMap > * >(argp1);
  {
    try {
      result = (bool)std_map_Sl_sword_SWBuf_Sc_AttributeValueMap_Sg____nonzero__((std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > > const *)arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_AttributeListMap___bool__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::map< sword::SWBuf,AttributeValueMap > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_sword__SWBuf_AttributeValueMap_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AttributeListMap___bool__" "', argument " "1"" of type '" "std::map< sword::SWBuf,AttributeValueMap > const *""'"); 
  }
  arg1 = reinterpret_cast< std::map< sword::SWBuf,AttributeValueMap > * >(argp1);
  {
    try {
      result = (bool)std_map_Sl_sword_SWBuf_Sc_AttributeValueMap_Sg____bool__((std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > > const *)arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_AttributeListMap___len__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::map< sword::SWBuf,AttributeValueMap > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > >::size_type result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_sword__SWBuf_AttributeValueMap_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AttributeListMap___len__" "', argument " "1"" of type '" "std::map< sword::SWBuf,AttributeValueMap > const *""'"); 
  }
  arg1 = reinterpret_cast< std::map< sword::SWBuf,AttributeValueMap > * >(argp1);
  {
    try {
      result = std_map_Sl_sword_SWBuf_Sc_AttributeValueMap_Sg____len__((std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > > const *)arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_AttributeListMap___getitem__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::map< sword::SWBuf,AttributeValueMap > *arg1 = 0 ;
  std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > >::key_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > >::mapped_type *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "AttributeListMap___getitem__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_sword__SWBuf_AttributeValueMap_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AttributeListMap___getitem__" "', argument " "1"" of type '" "std::map< sword::SWBuf,AttributeValueMap > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< sword::SWBuf,AttributeValueMap > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_sword__SWBuf,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "AttributeListMap___getitem__" "', argument " "2"" of type '" "std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > >::key_type const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "AttributeListMap___getitem__" "', argument " "2"" of type '" "std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > >::key_type const &""'"); 
  }
  arg2 = reinterpret_cast< std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > >::key_type * >(argp2);
  {
    try {
      try {
        result = (std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > >::mapped_type *) &std_map_Sl_sword_SWBuf_Sc_AttributeValueMap_Sg____getitem__(arg1,(sword::SWBuf const &)*arg2);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = swig::from(static_cast< std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_AttributeListMap___delitem__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::map< sword::SWBuf,AttributeValueMap > *arg1 = 0 ;
  std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > >::key_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "AttributeListMap___delitem__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_sword__SWBuf_AttributeValueMap_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AttributeListMap___delitem__" "', argument " "1"" of type '" "std::map< sword::SWBuf,AttributeValueMap > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< sword::SWBuf,AttributeValueMap > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_sword__SWBuf,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "AttributeListMap___delitem__" "', argument " "2"" of type '" "std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > >::key_type const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "AttributeListMap___delitem__" "', argument " "2"" of type '" "std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > >::key_type const &""'"); 
  }
  arg2 = reinterpret_cast< std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > >::key_type * >(argp2);
  {
    try {
      try {
        std_map_Sl_sword_SWBuf_Sc_AttributeValueMap_Sg____delitem__(arg1,(sword::SWBuf const &)*arg2);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_AttributeListMap_has_key(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::map< sword::SWBuf,AttributeValueMap > *arg1 = 0 ;
  std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > >::key_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "AttributeListMap_has_key", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_sword__SWBuf_AttributeValueMap_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AttributeListMap_has_key" "', argument " "1"" of type '" "std::map< sword::SWBuf,AttributeValueMap > const *""'"); 
  }
  arg1 = reinterpret_cast< std::map< sword::SWBuf,AttributeValueMap > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_sword__SWBuf,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "AttributeListMap_has_key" "', argument " "2"" of type '" "std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > >::key_type const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "AttributeListMap_has_key" "', argument " "2"" of type '" "std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > >::key_type const &""'"); 
  }
  arg2 = reinterpret_cast< std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > >::key_type * >(argp2);
  {
    try {
      result = (bool)std_map_Sl_sword_SWBuf_Sc_AttributeValueMap_Sg__has_key((std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > > const *)arg1,(sword::SWBuf const &)*arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_AttributeListMap_keys(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::map< sword::SWBuf,AttributeValueMap > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_sword__SWBuf_AttributeValueMap_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AttributeListMap_keys" "', argument " "1"" of type '" "std::map< sword::SWBuf,AttributeValueMap > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< sword::SWBuf,AttributeValueMap > * >(argp1);
  {
    try {
      result = (PyObject *)std_map_Sl_sword_SWBuf_Sc_AttributeValueMap_Sg__keys(arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = result;
  if (!resultobj) SWIG_fail;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_AttributeListMap_values(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::map< sword::SWBuf,AttributeValueMap > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_sword__SWBuf_AttributeValueMap_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AttributeListMap_values" "', argument " "1"" of type '" "std::map< sword::SWBuf,AttributeValueMap > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< sword::SWBuf,AttributeValueMap > * >(argp1);
  {
    try {
      result = (PyObject *)std_map_Sl_sword_SWBuf_Sc_AttributeValueMap_Sg__values(arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = result;
  if (!resultobj) SWIG_fail;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_AttributeListMap_items(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::map< sword::SWBuf,AttributeValueMap > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_sword__SWBuf_AttributeValueMap_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AttributeListMap_items" "', argument " "1"" of type '" "std::map< sword::SWBuf,AttributeValueMap > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< sword::SWBuf,AttributeValueMap > * >(argp1);
  {
    try {
      result = (PyObject *)std_map_Sl_sword_SWBuf_Sc_AttributeValueMap_Sg__items(arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = result;
  if (!resultobj) SWIG_fail;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_AttributeListMap___contains__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::map< sword::SWBuf,AttributeValueMap > *arg1 = 0 ;
  std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > >::key_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "AttributeListMap___contains__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_sword__SWBuf_AttributeValueMap_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AttributeListMap___contains__" "', argument " "1"" of type '" "std::map< sword::SWBuf,AttributeValueMap > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< sword::SWBuf,AttributeValueMap > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_sword__SWBuf,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "AttributeListMap___contains__" "', argument " "2"" of type '" "std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > >::key_type const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "AttributeListMap___contains__" "', argument " "2"" of type '" "std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > >::key_type const &""'"); 
  }
  arg2 = reinterpret_cast< std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > >::key_type * >(argp2);
  {
    try {
      result = (bool)std_map_Sl_sword_SWBuf_Sc_AttributeValueMap_Sg____contains__(arg1,(sword::SWBuf const &)*arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_AttributeListMap_key_iterator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::map< sword::SWBuf,AttributeValueMap > *arg1 = 0 ;
  PyObject **arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  swig::SwigPyIterator *result = 0 ;
  
  arg2 = &swig_obj[0];
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_sword__SWBuf_AttributeValueMap_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AttributeListMap_key_iterator" "', argument " "1"" of type '" "std::map< sword::SWBuf,AttributeValueMap > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< sword::SWBuf,AttributeValueMap > * >(argp1);
  {
    try {
      result = (swig::SwigPyIterator *)std_map_Sl_sword_SWBuf_Sc_AttributeValueMap_Sg__key_iterator(arg1,arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  if (!result) SWIG_fail;
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_AttributeListMap_value_iterator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::map< sword::SWBuf,AttributeValueMap > *arg1 = 0 ;
  PyObject **arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  swig::SwigPyIterator *result = 0 ;
  
  arg2 = &swig_obj[0];
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_sword__SWBuf_AttributeValueMap_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AttributeListMap_value_iterator" "', argument " "1"" of type '" "std::map< sword::SWBuf,AttributeValueMap > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< sword::SWBuf,AttributeValueMap > * >(argp1);
  {
    try {
      result = (swig::SwigPyIterator *)std_map_Sl_sword_SWBuf_Sc_AttributeValueMap_Sg__value_iterator(arg1,arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  if (!result) SWIG_fail;
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_AttributeListMap___setitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::map< sword::SWBuf,AttributeValueMap > *arg1 = 0 ;
  std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > >::key_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_sword__SWBuf_AttributeValueMap_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AttributeListMap___setitem__" "', argument " "1"" of type '" "std::map< sword::SWBuf,AttributeValueMap > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< sword::SWBuf,AttributeValueMap > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_sword__SWBuf,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "AttributeListMap___setitem__" "', argument " "2"" of type '" "std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > >::key_type const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "AttributeListMap___setitem__" "', argument " "2"" of type '" "std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > >::key_type const &""'"); 
  }
  arg2 = reinterpret_cast< std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > >::key_type * >(argp2);
  {
    try {
      std_map_Sl_sword_SWBuf_Sc_AttributeValueMap_Sg____setitem____SWIG_0(arg1,(sword::SWBuf const &)*arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_AttributeListMap___setitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::map< sword::SWBuf,AttributeValueMap > *arg1 = 0 ;
  std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > >::key_type *arg2 = 0 ;
  std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > >::mapped_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_sword__SWBuf_AttributeValueMap_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AttributeListMap___setitem__" "', argument " "1"" of type '" "std::map< sword::SWBuf,AttributeValueMap > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< sword::SWBuf,AttributeValueMap > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_sword__SWBuf,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "AttributeListMap___setitem__" "', argument " "2"" of type '" "std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > >::key_type const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "AttributeListMap___setitem__" "', argument " "2"" of type '" "std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > >::key_type const &""'"); 
  }
  arg2 = reinterpret_cast< std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > >::key_type * >(argp2);
  {
    std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > *ptr = (std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "AttributeListMap___setitem__" "', argument " "3"" of type '" "std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > >::mapped_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "AttributeListMap___setitem__" "', argument " "3"" of type '" "std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > >::mapped_type const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      try {
        std_map_Sl_sword_SWBuf_Sc_AttributeValueMap_Sg____setitem____SWIG_1(arg1,(sword::SWBuf const &)*arg2,(std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > const &)*arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_AttributeListMap___setitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "AttributeListMap___setitem__", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_sword__SWBuf, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_AttributeListMap___setitem____SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_sword__SWBuf, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_AttributeListMap___setitem____SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'AttributeListMap___setitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::map< sword::SWBuf,AttributeValueMap >::__setitem__(std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > >::key_type const &)\n"
    "    std::map< sword::SWBuf,AttributeValueMap >::__setitem__(std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > >::key_type const &,std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > >::mapped_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_AttributeListMap_asdict(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::map< sword::SWBuf,AttributeValueMap > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_sword__SWBuf_AttributeValueMap_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AttributeListMap_asdict" "', argument " "1"" of type '" "std::map< sword::SWBuf,AttributeValueMap > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< sword::SWBuf,AttributeValueMap > * >(argp1);
  {
    try {
      result = (PyObject *)std_map_Sl_sword_SWBuf_Sc_AttributeValueMap_Sg__asdict(arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = result;
  if (!resultobj) SWIG_fail;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AttributeListMap__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  std::map< sword::SWBuf,AttributeValueMap > *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (std::map< sword::SWBuf,AttributeValueMap > *)new std::map< sword::SWBuf,AttributeValueMap >(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__mapT_sword__SWBuf_AttributeValueMap_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AttributeListMap__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::map< sword::SWBuf,AttributeValueMap > *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  std::map< sword::SWBuf,AttributeValueMap > *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > > > > *ptr = (std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > > > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_AttributeListMap" "', argument " "1"" of type '" "std::map< sword::SWBuf,AttributeValueMap > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_AttributeListMap" "', argument " "1"" of type '" "std::map< sword::SWBuf,AttributeValueMap > const &""'"); 
    }
    arg1 = ptr;
  }
  {
    try {
      result = (std::map< sword::SWBuf,AttributeValueMap > *)new std::map< sword::SWBuf,AttributeValueMap >((std::map< sword::SWBuf,AttributeValueMap > const &)*arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__mapT_sword__SWBuf_AttributeValueMap_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AttributeListMap(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_AttributeListMap", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_AttributeListMap__SWIG_1(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_std__lessT_sword__SWBuf_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_AttributeListMap__SWIG_0(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_AttributeListMap__SWIG_2(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_AttributeListMap'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::map< sword::SWBuf,AttributeValueMap >::map(std::less< sword::SWBuf > const &)\n"
    "    std::map< sword::SWBuf,AttributeValueMap >::map()\n"
    "    std::map< sword::SWBuf,AttributeValueMap >::map(std::map< sword::SWBuf,AttributeValueMap > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_AttributeListMap_empty(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::map< sword::SWBuf,AttributeValueMap > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_sword__SWBuf_AttributeValueMap_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AttributeListMap_empty" "', argument " "1"" of type '" "std::map< sword::SWBuf,AttributeValueMap > const *""'"); 
  }
  arg1 = reinterpret_cast< std::map< sword::SWBuf,AttributeValueMap > * >(argp1);
  {
    try {
      result = (bool)((std::map< sword::SWBuf,AttributeValueMap > const *)arg1)->empty(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_AttributeListMap_size(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::map< sword::SWBuf,AttributeValueMap > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > >::size_type result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_sword__SWBuf_AttributeValueMap_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AttributeListMap_size" "', argument " "1"" of type '" "std::map< sword::SWBuf,AttributeValueMap > const *""'"); 
  }
  arg1 = reinterpret_cast< std::map< sword::SWBuf,AttributeValueMap > * >(argp1);
  {
    try {
      result = ((std::map< sword::SWBuf,AttributeValueMap > const *)arg1)->size(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_AttributeListMap_swap(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::map< sword::SWBuf,AttributeValueMap > *arg1 = 0 ;
  std::map< sword::SWBuf,AttributeValueMap > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "AttributeListMap_swap", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_sword__SWBuf_AttributeValueMap_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AttributeListMap_swap" "', argument " "1"" of type '" "std::map< sword::SWBuf,AttributeValueMap > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< sword::SWBuf,AttributeValueMap > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__mapT_sword__SWBuf_AttributeValueMap_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "AttributeListMap_swap" "', argument " "2"" of type '" "std::map< sword::SWBuf,AttributeValueMap > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "AttributeListMap_swap" "', argument " "2"" of type '" "std::map< sword::SWBuf,AttributeValueMap > &""'"); 
  }
  arg2 = reinterpret_cast< std::map< sword::SWBuf,AttributeValueMap > * >(argp2);
  {
    try {
      (arg1)->swap(*arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_AttributeListMap_begin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::map< sword::SWBuf,AttributeValueMap > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > >::iterator > result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_sword__SWBuf_AttributeValueMap_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AttributeListMap_begin" "', argument " "1"" of type '" "std::map< sword::SWBuf,AttributeValueMap > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< sword::SWBuf,AttributeValueMap > * >(argp1);
  {
    try {
      result = (arg1)->begin(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_AttributeListMap_end(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::map< sword::SWBuf,AttributeValueMap > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > >::iterator > result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_sword__SWBuf_AttributeValueMap_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AttributeListMap_end" "', argument " "1"" of type '" "std::map< sword::SWBuf,AttributeValueMap > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< sword::SWBuf,AttributeValueMap > * >(argp1);
  {
    try {
      result = (arg1)->end(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_AttributeListMap_rbegin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::map< sword::SWBuf,AttributeValueMap > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > >::reverse_iterator > result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_sword__SWBuf_AttributeValueMap_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AttributeListMap_rbegin" "', argument " "1"" of type '" "std::map< sword::SWBuf,AttributeValueMap > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< sword::SWBuf,AttributeValueMap > * >(argp1);
  {
    try {
      result = (arg1)->rbegin(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > >::reverse_iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_AttributeListMap_rend(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::map< sword::SWBuf,AttributeValueMap > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > >::reverse_iterator > result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_sword__SWBuf_AttributeValueMap_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AttributeListMap_rend" "', argument " "1"" of type '" "std::map< sword::SWBuf,AttributeValueMap > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< sword::SWBuf,AttributeValueMap > * >(argp1);
  {
    try {
      result = (arg1)->rend(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > >::reverse_iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_AttributeListMap_clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::map< sword::SWBuf,AttributeValueMap > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_sword__SWBuf_AttributeValueMap_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AttributeListMap_clear" "', argument " "1"" of type '" "std::map< sword::SWBuf,AttributeValueMap > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< sword::SWBuf,AttributeValueMap > * >(argp1);
  {
    try {
      (arg1)->clear(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_AttributeListMap_get_allocator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::map< sword::SWBuf,AttributeValueMap > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< std::allocator< std::pair< sword::SWBuf const,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > > > > result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_sword__SWBuf_AttributeValueMap_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AttributeListMap_get_allocator" "', argument " "1"" of type '" "std::map< sword::SWBuf,AttributeValueMap > const *""'"); 
  }
  arg1 = reinterpret_cast< std::map< sword::SWBuf,AttributeValueMap > * >(argp1);
  {
    try {
      result = ((std::map< sword::SWBuf,AttributeValueMap > const *)arg1)->get_allocator(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj((new std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > >::allocator_type(result)), SWIGTYPE_p_std__allocatorT_std__pairT_sword__SWBuf_const_std__mapT_sword__SWBuf_sword__SWBuf_t_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_AttributeListMap_erase__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::map< sword::SWBuf,AttributeValueMap > *arg1 = 0 ;
  std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > >::key_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > >::size_type result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_sword__SWBuf_AttributeValueMap_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AttributeListMap_erase" "', argument " "1"" of type '" "std::map< sword::SWBuf,AttributeValueMap > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< sword::SWBuf,AttributeValueMap > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_sword__SWBuf,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "AttributeListMap_erase" "', argument " "2"" of type '" "std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > >::key_type const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "AttributeListMap_erase" "', argument " "2"" of type '" "std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > >::key_type const &""'"); 
  }
  arg2 = reinterpret_cast< std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > >::key_type * >(argp2);
  {
    try {
      result = (arg1)->erase((std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > >::key_type const &)*arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_AttributeListMap_count(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::map< sword::SWBuf,AttributeValueMap > *arg1 = 0 ;
  std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > >::key_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > >::size_type result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "AttributeListMap_count", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_sword__SWBuf_AttributeValueMap_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AttributeListMap_count" "', argument " "1"" of type '" "std::map< sword::SWBuf,AttributeValueMap > const *""'"); 
  }
  arg1 = reinterpret_cast< std::map< sword::SWBuf,AttributeValueMap > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_sword__SWBuf,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "AttributeListMap_count" "', argument " "2"" of type '" "std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > >::key_type const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "AttributeListMap_count" "', argument " "2"" of type '" "std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > >::key_type const &""'"); 
  }
  arg2 = reinterpret_cast< std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > >::key_type * >(argp2);
  {
    try {
      result = ((std::map< sword::SWBuf,AttributeValueMap > const *)arg1)->count((std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > >::key_type const &)*arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_AttributeListMap_erase__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::map< sword::SWBuf,AttributeValueMap > *arg1 = 0 ;
  SwigValueWrapper< std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > >::iterator > arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_sword__SWBuf_AttributeValueMap_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AttributeListMap_erase" "', argument " "1"" of type '" "std::map< sword::SWBuf,AttributeValueMap > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< sword::SWBuf,AttributeValueMap > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "AttributeListMap_erase" "', argument " "2"" of type '" "std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "AttributeListMap_erase" "', argument " "2"" of type '" "std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > >::iterator""'");
    }
  }
  {
    try {
      std_map_Sl_sword_SWBuf_Sc_AttributeValueMap_Sg__erase__SWIG_1(arg1,SWIG_STD_MOVE(arg2)); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_AttributeListMap_erase__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::map< sword::SWBuf,AttributeValueMap > *arg1 = 0 ;
  SwigValueWrapper< std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > >::iterator > arg2 ;
  SwigValueWrapper< std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > >::iterator > arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  swig::SwigPyIterator *iter3 = 0 ;
  int res3 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_sword__SWBuf_AttributeValueMap_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AttributeListMap_erase" "', argument " "1"" of type '" "std::map< sword::SWBuf,AttributeValueMap > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< sword::SWBuf,AttributeValueMap > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "AttributeListMap_erase" "', argument " "2"" of type '" "std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "AttributeListMap_erase" "', argument " "2"" of type '" "std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > >::iterator""'");
    }
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], SWIG_as_voidptrptr(&iter3), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res3) || !iter3) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "AttributeListMap_erase" "', argument " "3"" of type '" "std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > >::iterator > *>(iter3);
    if (iter_t) {
      arg3 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "AttributeListMap_erase" "', argument " "3"" of type '" "std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > >::iterator""'");
    }
  }
  {
    try {
      std_map_Sl_sword_SWBuf_Sc_AttributeValueMap_Sg__erase__SWIG_2(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3)); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_AttributeListMap_erase(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "AttributeListMap_erase", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_sword__SWBuf, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_AttributeListMap_erase__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > >::iterator > *>(iter) != 0));
      if (_v) {
        return _wrap_AttributeListMap_erase__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > >::iterator > *>(iter) != 0));
      if (_v) {
        swig::SwigPyIterator *iter = 0;
        int res = SWIG_ConvertPtr(argv[2], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
        _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > >::iterator > *>(iter) != 0));
        if (_v) {
          return _wrap_AttributeListMap_erase__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'AttributeListMap_erase'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::map< sword::SWBuf,AttributeValueMap >::erase(std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > >::key_type const &)\n"
    "    std::map< sword::SWBuf,AttributeValueMap >::erase(std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > >::iterator)\n"
    "    std::map< sword::SWBuf,AttributeValueMap >::erase(std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > >::iterator,std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > >::iterator)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_AttributeListMap_find(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::map< sword::SWBuf,AttributeValueMap > *arg1 = 0 ;
  std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > >::key_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SwigValueWrapper< std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > >::iterator > result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "AttributeListMap_find", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_sword__SWBuf_AttributeValueMap_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AttributeListMap_find" "', argument " "1"" of type '" "std::map< sword::SWBuf,AttributeValueMap > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< sword::SWBuf,AttributeValueMap > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_sword__SWBuf,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "AttributeListMap_find" "', argument " "2"" of type '" "std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > >::key_type const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "AttributeListMap_find" "', argument " "2"" of type '" "std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > >::key_type const &""'"); 
  }
  arg2 = reinterpret_cast< std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > >::key_type * >(argp2);
  {
    try {
      result = (arg1)->find((std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > >::key_type const &)*arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_AttributeListMap_lower_bound(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::map< sword::SWBuf,AttributeValueMap > *arg1 = 0 ;
  std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > >::key_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SwigValueWrapper< std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > >::iterator > result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "AttributeListMap_lower_bound", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_sword__SWBuf_AttributeValueMap_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AttributeListMap_lower_bound" "', argument " "1"" of type '" "std::map< sword::SWBuf,AttributeValueMap > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< sword::SWBuf,AttributeValueMap > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_sword__SWBuf,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "AttributeListMap_lower_bound" "', argument " "2"" of type '" "std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > >::key_type const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "AttributeListMap_lower_bound" "', argument " "2"" of type '" "std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > >::key_type const &""'"); 
  }
  arg2 = reinterpret_cast< std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > >::key_type * >(argp2);
  {
    try {
      result = (arg1)->lower_bound((std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > >::key_type const &)*arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_AttributeListMap_upper_bound(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::map< sword::SWBuf,AttributeValueMap > *arg1 = 0 ;
  std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > >::key_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SwigValueWrapper< std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > >::iterator > result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "AttributeListMap_upper_bound", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_sword__SWBuf_AttributeValueMap_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AttributeListMap_upper_bound" "', argument " "1"" of type '" "std::map< sword::SWBuf,AttributeValueMap > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< sword::SWBuf,AttributeValueMap > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_sword__SWBuf,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "AttributeListMap_upper_bound" "', argument " "2"" of type '" "std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > >::key_type const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "AttributeListMap_upper_bound" "', argument " "2"" of type '" "std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > >::key_type const &""'"); 
  }
  arg2 = reinterpret_cast< std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > >::key_type * >(argp2);
  {
    try {
      result = (arg1)->upper_bound((std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > >::key_type const &)*arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_AttributeListMap(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::map< sword::SWBuf,AttributeValueMap > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_sword__SWBuf_AttributeValueMap_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AttributeListMap" "', argument " "1"" of type '" "std::map< sword::SWBuf,AttributeValueMap > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< sword::SWBuf,AttributeValueMap > * >(argp1);
  {
    try {
      delete arg1; 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *AttributeListMap_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__mapT_sword__SWBuf_AttributeValueMap_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *AttributeListMap_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_AttributeTypeListMap__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::less< sword::SWBuf > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::map< sword::SWBuf,AttributeListMap > *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_std__lessT_sword__SWBuf_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_AttributeTypeListMap" "', argument " "1"" of type '" "std::less< sword::SWBuf > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_AttributeTypeListMap" "', argument " "1"" of type '" "std::less< sword::SWBuf > const &""'"); 
  }
  arg1 = reinterpret_cast< std::less< sword::SWBuf > * >(argp1);
  {
    try {
      result = (std::map< sword::SWBuf,AttributeListMap > *)new std::map< sword::SWBuf,AttributeListMap >((std::less< sword::SWBuf > const &)*arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__mapT_sword__SWBuf_AttributeListMap_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_AttributeTypeListMap_iterator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::map< sword::SWBuf,AttributeListMap > *arg1 = 0 ;
  PyObject **arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  swig::SwigPyIterator *result = 0 ;
  
  arg2 = &swig_obj[0];
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_sword__SWBuf_AttributeListMap_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AttributeTypeListMap_iterator" "', argument " "1"" of type '" "std::map< sword::SWBuf,AttributeListMap > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< sword::SWBuf,AttributeListMap > * >(argp1);
  {
    try {
      result = (swig::SwigPyIterator *)std_map_Sl_sword_SWBuf_Sc_AttributeListMap_Sg__iterator(arg1,arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  if (!result) SWIG_fail;
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_AttributeTypeListMap___nonzero__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::map< sword::SWBuf,AttributeListMap > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_sword__SWBuf_AttributeListMap_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AttributeTypeListMap___nonzero__" "', argument " "1"" of type '" "std::map< sword::SWBuf,AttributeListMap > const *""'"); 
  }
  arg1 = reinterpret_cast< std::map< sword::SWBuf,AttributeListMap > * >(argp1);
  {
    try {
      result = (bool)std_map_Sl_sword_SWBuf_Sc_AttributeListMap_Sg____nonzero__((std::map< sword::SWBuf,std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > > > > > const *)arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_AttributeTypeListMap___bool__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::map< sword::SWBuf,AttributeListMap > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_sword__SWBuf_AttributeListMap_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AttributeTypeListMap___bool__" "', argument " "1"" of type '" "std::map< sword::SWBuf,AttributeListMap > const *""'"); 
  }
  arg1 = reinterpret_cast< std::map< sword::SWBuf,AttributeListMap > * >(argp1);
  {
    try {
      result = (bool)std_map_Sl_sword_SWBuf_Sc_AttributeListMap_Sg____bool__((std::map< sword::SWBuf,std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > > > > > const *)arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_AttributeTypeListMap___len__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::map< sword::SWBuf,AttributeListMap > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::map< sword::SWBuf,std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > > > > >::size_type result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_sword__SWBuf_AttributeListMap_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AttributeTypeListMap___len__" "', argument " "1"" of type '" "std::map< sword::SWBuf,AttributeListMap > const *""'"); 
  }
  arg1 = reinterpret_cast< std::map< sword::SWBuf,AttributeListMap > * >(argp1);
  {
    try {
      result = std_map_Sl_sword_SWBuf_Sc_AttributeListMap_Sg____len__((std::map< sword::SWBuf,std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > > > > > const *)arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_AttributeTypeListMap___getitem__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::map< sword::SWBuf,AttributeListMap > *arg1 = 0 ;
  std::map< sword::SWBuf,std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > > > > >::key_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  std::map< sword::SWBuf,std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > > > > >::mapped_type *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "AttributeTypeListMap___getitem__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_sword__SWBuf_AttributeListMap_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AttributeTypeListMap___getitem__" "', argument " "1"" of type '" "std::map< sword::SWBuf,AttributeListMap > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< sword::SWBuf,AttributeListMap > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_sword__SWBuf,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "AttributeTypeListMap___getitem__" "', argument " "2"" of type '" "std::map< sword::SWBuf,std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > > > > >::key_type const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "AttributeTypeListMap___getitem__" "', argument " "2"" of type '" "std::map< sword::SWBuf,std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > > > > >::key_type const &""'"); 
  }
  arg2 = reinterpret_cast< std::map< sword::SWBuf,std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > > > > >::key_type * >(argp2);
  {
    try {
      try {
        result = (std::map< sword::SWBuf,std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > > > > >::mapped_type *) &std_map_Sl_sword_SWBuf_Sc_AttributeListMap_Sg____getitem__(arg1,(sword::SWBuf const &)*arg2);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = swig::from(static_cast< std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > > > > >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_AttributeTypeListMap___delitem__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::map< sword::SWBuf,AttributeListMap > *arg1 = 0 ;
  std::map< sword::SWBuf,std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > > > > >::key_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "AttributeTypeListMap___delitem__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_sword__SWBuf_AttributeListMap_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AttributeTypeListMap___delitem__" "', argument " "1"" of type '" "std::map< sword::SWBuf,AttributeListMap > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< sword::SWBuf,AttributeListMap > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_sword__SWBuf,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "AttributeTypeListMap___delitem__" "', argument " "2"" of type '" "std::map< sword::SWBuf,std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > > > > >::key_type const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "AttributeTypeListMap___delitem__" "', argument " "2"" of type '" "std::map< sword::SWBuf,std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > > > > >::key_type const &""'"); 
  }
  arg2 = reinterpret_cast< std::map< sword::SWBuf,std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > > > > >::key_type * >(argp2);
  {
    try {
      try {
        std_map_Sl_sword_SWBuf_Sc_AttributeListMap_Sg____delitem__(arg1,(sword::SWBuf const &)*arg2);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_AttributeTypeListMap_has_key(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::map< sword::SWBuf,AttributeListMap > *arg1 = 0 ;
  std::map< sword::SWBuf,std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > > > > >::key_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "AttributeTypeListMap_has_key", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_sword__SWBuf_AttributeListMap_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AttributeTypeListMap_has_key" "', argument " "1"" of type '" "std::map< sword::SWBuf,AttributeListMap > const *""'"); 
  }
  arg1 = reinterpret_cast< std::map< sword::SWBuf,AttributeListMap > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_sword__SWBuf,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "AttributeTypeListMap_has_key" "', argument " "2"" of type '" "std::map< sword::SWBuf,std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > > > > >::key_type const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "AttributeTypeListMap_has_key" "', argument " "2"" of type '" "std::map< sword::SWBuf,std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > > > > >::key_type const &""'"); 
  }
  arg2 = reinterpret_cast< std::map< sword::SWBuf,std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > > > > >::key_type * >(argp2);
  {
    try {
      result = (bool)std_map_Sl_sword_SWBuf_Sc_AttributeListMap_Sg__has_key((std::map< sword::SWBuf,std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > > > > > const *)arg1,(sword::SWBuf const &)*arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_AttributeTypeListMap_keys(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::map< sword::SWBuf,AttributeListMap > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_sword__SWBuf_AttributeListMap_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AttributeTypeListMap_keys" "', argument " "1"" of type '" "std::map< sword::SWBuf,AttributeListMap > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< sword::SWBuf,AttributeListMap > * >(argp1);
  {
    try {
      result = (PyObject *)std_map_Sl_sword_SWBuf_Sc_AttributeListMap_Sg__keys(arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = result;
  if (!resultobj) SWIG_fail;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_AttributeTypeListMap_values(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::map< sword::SWBuf,AttributeListMap > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_sword__SWBuf_AttributeListMap_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AttributeTypeListMap_values" "', argument " "1"" of type '" "std::map< sword::SWBuf,AttributeListMap > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< sword::SWBuf,AttributeListMap > * >(argp1);
  {
    try {
      result = (PyObject *)std_map_Sl_sword_SWBuf_Sc_AttributeListMap_Sg__values(arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = result;
  if (!resultobj) SWIG_fail;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_AttributeTypeListMap_items(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::map< sword::SWBuf,AttributeListMap > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_sword__SWBuf_AttributeListMap_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AttributeTypeListMap_items" "', argument " "1"" of type '" "std::map< sword::SWBuf,AttributeListMap > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< sword::SWBuf,AttributeListMap > * >(argp1);
  {
    try {
      result = (PyObject *)std_map_Sl_sword_SWBuf_Sc_AttributeListMap_Sg__items(arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = result;
  if (!resultobj) SWIG_fail;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_AttributeTypeListMap___contains__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::map< sword::SWBuf,AttributeListMap > *arg1 = 0 ;
  std::map< sword::SWBuf,std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > > > > >::key_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "AttributeTypeListMap___contains__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_sword__SWBuf_AttributeListMap_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AttributeTypeListMap___contains__" "', argument " "1"" of type '" "std::map< sword::SWBuf,AttributeListMap > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< sword::SWBuf,AttributeListMap > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_sword__SWBuf,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "AttributeTypeListMap___contains__" "', argument " "2"" of type '" "std::map< sword::SWBuf,std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > > > > >::key_type const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "AttributeTypeListMap___contains__" "', argument " "2"" of type '" "std::map< sword::SWBuf,std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > > > > >::key_type const &""'"); 
  }
  arg2 = reinterpret_cast< std::map< sword::SWBuf,std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > > > > >::key_type * >(argp2);
  {
    try {
      result = (bool)std_map_Sl_sword_SWBuf_Sc_AttributeListMap_Sg____contains__(arg1,(sword::SWBuf const &)*arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_AttributeTypeListMap_key_iterator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::map< sword::SWBuf,AttributeListMap > *arg1 = 0 ;
  PyObject **arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  swig::SwigPyIterator *result = 0 ;
  
  arg2 = &swig_obj[0];
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_sword__SWBuf_AttributeListMap_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AttributeTypeListMap_key_iterator" "', argument " "1"" of type '" "std::map< sword::SWBuf,AttributeListMap > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< sword::SWBuf,AttributeListMap > * >(argp1);
  {
    try {
      result = (swig::SwigPyIterator *)std_map_Sl_sword_SWBuf_Sc_AttributeListMap_Sg__key_iterator(arg1,arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  if (!result) SWIG_fail;
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_AttributeTypeListMap_value_iterator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::map< sword::SWBuf,AttributeListMap > *arg1 = 0 ;
  PyObject **arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  swig::SwigPyIterator *result = 0 ;
  
  arg2 = &swig_obj[0];
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_sword__SWBuf_AttributeListMap_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AttributeTypeListMap_value_iterator" "', argument " "1"" of type '" "std::map< sword::SWBuf,AttributeListMap > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< sword::SWBuf,AttributeListMap > * >(argp1);
  {
    try {
      result = (swig::SwigPyIterator *)std_map_Sl_sword_SWBuf_Sc_AttributeListMap_Sg__value_iterator(arg1,arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  if (!result) SWIG_fail;
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_AttributeTypeListMap___setitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::map< sword::SWBuf,AttributeListMap > *arg1 = 0 ;
  std::map< sword::SWBuf,std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > > > > >::key_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_sword__SWBuf_AttributeListMap_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AttributeTypeListMap___setitem__" "', argument " "1"" of type '" "std::map< sword::SWBuf,AttributeListMap > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< sword::SWBuf,AttributeListMap > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_sword__SWBuf,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "AttributeTypeListMap___setitem__" "', argument " "2"" of type '" "std::map< sword::SWBuf,std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > > > > >::key_type const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "AttributeTypeListMap___setitem__" "', argument " "2"" of type '" "std::map< sword::SWBuf,std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > > > > >::key_type const &""'"); 
  }
  arg2 = reinterpret_cast< std::map< sword::SWBuf,std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > > > > >::key_type * >(argp2);
  {
    try {
      std_map_Sl_sword_SWBuf_Sc_AttributeListMap_Sg____setitem____SWIG_0(arg1,(sword::SWBuf const &)*arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_AttributeTypeListMap___setitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::map< sword::SWBuf,AttributeListMap > *arg1 = 0 ;
  std::map< sword::SWBuf,std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > > > > >::key_type *arg2 = 0 ;
  std::map< sword::SWBuf,std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > > > > >::mapped_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_sword__SWBuf_AttributeListMap_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AttributeTypeListMap___setitem__" "', argument " "1"" of type '" "std::map< sword::SWBuf,AttributeListMap > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< sword::SWBuf,AttributeListMap > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_sword__SWBuf,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "AttributeTypeListMap___setitem__" "', argument " "2"" of type '" "std::map< sword::SWBuf,std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > > > > >::key_type const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "AttributeTypeListMap___setitem__" "', argument " "2"" of type '" "std::map< sword::SWBuf,std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > > > > >::key_type const &""'"); 
  }
  arg2 = reinterpret_cast< std::map< sword::SWBuf,std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > > > > >::key_type * >(argp2);
  {
    std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > > > > *ptr = (std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > > > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "AttributeTypeListMap___setitem__" "', argument " "3"" of type '" "std::map< sword::SWBuf,std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > > > > >::mapped_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "AttributeTypeListMap___setitem__" "', argument " "3"" of type '" "std::map< sword::SWBuf,std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > > > > >::mapped_type const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      try {
        std_map_Sl_sword_SWBuf_Sc_AttributeListMap_Sg____setitem____SWIG_1(arg1,(sword::SWBuf const &)*arg2,(std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > > > > const &)*arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_AttributeTypeListMap___setitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "AttributeTypeListMap___setitem__", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::map< sword::SWBuf,std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > > > >,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > > > > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_sword__SWBuf, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_AttributeTypeListMap___setitem____SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::map< sword::SWBuf,std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > > > >,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > > > > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_sword__SWBuf, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_AttributeTypeListMap___setitem____SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'AttributeTypeListMap___setitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::map< sword::SWBuf,AttributeListMap >::__setitem__(std::map< sword::SWBuf,std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > > > > >::key_type const &)\n"
    "    std::map< sword::SWBuf,AttributeListMap >::__setitem__(std::map< sword::SWBuf,std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > > > > >::key_type const &,std::map< sword::SWBuf,std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > > > > >::mapped_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_AttributeTypeListMap_asdict(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::map< sword::SWBuf,AttributeListMap > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_sword__SWBuf_AttributeListMap_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AttributeTypeListMap_asdict" "', argument " "1"" of type '" "std::map< sword::SWBuf,AttributeListMap > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< sword::SWBuf,AttributeListMap > * >(argp1);
  {
    try {
      result = (PyObject *)std_map_Sl_sword_SWBuf_Sc_AttributeListMap_Sg__asdict(arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = result;
  if (!resultobj) SWIG_fail;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AttributeTypeListMap__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  std::map< sword::SWBuf,AttributeListMap > *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (std::map< sword::SWBuf,AttributeListMap > *)new std::map< sword::SWBuf,AttributeListMap >(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__mapT_sword__SWBuf_AttributeListMap_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AttributeTypeListMap__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::map< sword::SWBuf,AttributeListMap > *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  std::map< sword::SWBuf,AttributeListMap > *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    std::map< sword::SWBuf,std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > > > >,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > > > > > > > *ptr = (std::map< sword::SWBuf,std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > > > >,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > > > > > > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_AttributeTypeListMap" "', argument " "1"" of type '" "std::map< sword::SWBuf,AttributeListMap > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_AttributeTypeListMap" "', argument " "1"" of type '" "std::map< sword::SWBuf,AttributeListMap > const &""'"); 
    }
    arg1 = ptr;
  }
  {
    try {
      result = (std::map< sword::SWBuf,AttributeListMap > *)new std::map< sword::SWBuf,AttributeListMap >((std::map< sword::SWBuf,AttributeListMap > const &)*arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__mapT_sword__SWBuf_AttributeListMap_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AttributeTypeListMap(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_AttributeTypeListMap", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_AttributeTypeListMap__SWIG_1(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_std__lessT_sword__SWBuf_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_AttributeTypeListMap__SWIG_0(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::map< sword::SWBuf,std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > > > >,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > > > > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_AttributeTypeListMap__SWIG_2(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_AttributeTypeListMap'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::map< sword::SWBuf,AttributeListMap >::map(std::less< sword::SWBuf > const &)\n"
    "    std::map< sword::SWBuf,AttributeListMap >::map()\n"
    "    std::map< sword::SWBuf,AttributeListMap >::map(std::map< sword::SWBuf,AttributeListMap > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_AttributeTypeListMap_empty(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::map< sword::SWBuf,AttributeListMap > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_sword__SWBuf_AttributeListMap_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AttributeTypeListMap_empty" "', argument " "1"" of type '" "std::map< sword::SWBuf,AttributeListMap > const *""'"); 
  }
  arg1 = reinterpret_cast< std::map< sword::SWBuf,AttributeListMap > * >(argp1);
  {
    try {
      result = (bool)((std::map< sword::SWBuf,AttributeListMap > const *)arg1)->empty(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_AttributeTypeListMap_size(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::map< sword::SWBuf,AttributeListMap > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::map< sword::SWBuf,std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > > > > >::size_type result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_sword__SWBuf_AttributeListMap_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AttributeTypeListMap_size" "', argument " "1"" of type '" "std::map< sword::SWBuf,AttributeListMap > const *""'"); 
  }
  arg1 = reinterpret_cast< std::map< sword::SWBuf,AttributeListMap > * >(argp1);
  {
    try {
      result = ((std::map< sword::SWBuf,AttributeListMap > const *)arg1)->size(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_AttributeTypeListMap_swap(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::map< sword::SWBuf,AttributeListMap > *arg1 = 0 ;
  std::map< sword::SWBuf,AttributeListMap > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "AttributeTypeListMap_swap", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_sword__SWBuf_AttributeListMap_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AttributeTypeListMap_swap" "', argument " "1"" of type '" "std::map< sword::SWBuf,AttributeListMap > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< sword::SWBuf,AttributeListMap > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__mapT_sword__SWBuf_AttributeListMap_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "AttributeTypeListMap_swap" "', argument " "2"" of type '" "std::map< sword::SWBuf,AttributeListMap > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "AttributeTypeListMap_swap" "', argument " "2"" of type '" "std::map< sword::SWBuf,AttributeListMap > &""'"); 
  }
  arg2 = reinterpret_cast< std::map< sword::SWBuf,AttributeListMap > * >(argp2);
  {
    try {
      (arg1)->swap(*arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_AttributeTypeListMap_begin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::map< sword::SWBuf,AttributeListMap > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< std::map< sword::SWBuf,std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > > > > >::iterator > result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_sword__SWBuf_AttributeListMap_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AttributeTypeListMap_begin" "', argument " "1"" of type '" "std::map< sword::SWBuf,AttributeListMap > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< sword::SWBuf,AttributeListMap > * >(argp1);
  {
    try {
      result = (arg1)->begin(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::map< sword::SWBuf,std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > > > > >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_AttributeTypeListMap_end(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::map< sword::SWBuf,AttributeListMap > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< std::map< sword::SWBuf,std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > > > > >::iterator > result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_sword__SWBuf_AttributeListMap_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AttributeTypeListMap_end" "', argument " "1"" of type '" "std::map< sword::SWBuf,AttributeListMap > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< sword::SWBuf,AttributeListMap > * >(argp1);
  {
    try {
      result = (arg1)->end(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::map< sword::SWBuf,std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > > > > >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_AttributeTypeListMap_rbegin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::map< sword::SWBuf,AttributeListMap > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< std::map< sword::SWBuf,std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > > > > >::reverse_iterator > result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_sword__SWBuf_AttributeListMap_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AttributeTypeListMap_rbegin" "', argument " "1"" of type '" "std::map< sword::SWBuf,AttributeListMap > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< sword::SWBuf,AttributeListMap > * >(argp1);
  {
    try {
      result = (arg1)->rbegin(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::map< sword::SWBuf,std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > > > > >::reverse_iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_AttributeTypeListMap_rend(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::map< sword::SWBuf,AttributeListMap > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< std::map< sword::SWBuf,std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > > > > >::reverse_iterator > result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_sword__SWBuf_AttributeListMap_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AttributeTypeListMap_rend" "', argument " "1"" of type '" "std::map< sword::SWBuf,AttributeListMap > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< sword::SWBuf,AttributeListMap > * >(argp1);
  {
    try {
      result = (arg1)->rend(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::map< sword::SWBuf,std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > > > > >::reverse_iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_AttributeTypeListMap_clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::map< sword::SWBuf,AttributeListMap > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_sword__SWBuf_AttributeListMap_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AttributeTypeListMap_clear" "', argument " "1"" of type '" "std::map< sword::SWBuf,AttributeListMap > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< sword::SWBuf,AttributeListMap > * >(argp1);
  {
    try {
      (arg1)->clear(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_AttributeTypeListMap_get_allocator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::map< sword::SWBuf,AttributeListMap > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< std::allocator< std::pair< sword::SWBuf const,std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > > > > > > > result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_sword__SWBuf_AttributeListMap_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AttributeTypeListMap_get_allocator" "', argument " "1"" of type '" "std::map< sword::SWBuf,AttributeListMap > const *""'"); 
  }
  arg1 = reinterpret_cast< std::map< sword::SWBuf,AttributeListMap > * >(argp1);
  {
    try {
      result = ((std::map< sword::SWBuf,AttributeListMap > const *)arg1)->get_allocator(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj((new std::map< sword::SWBuf,std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > > > > >::allocator_type(result)), SWIGTYPE_p_std__allocatorT_std__pairT_sword__SWBuf_const_std__mapT_sword__SWBuf_AttributeValueMap_t_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_AttributeTypeListMap_erase__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::map< sword::SWBuf,AttributeListMap > *arg1 = 0 ;
  std::map< sword::SWBuf,std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > > > > >::key_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  std::map< sword::SWBuf,std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > > > > >::size_type result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_sword__SWBuf_AttributeListMap_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AttributeTypeListMap_erase" "', argument " "1"" of type '" "std::map< sword::SWBuf,AttributeListMap > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< sword::SWBuf,AttributeListMap > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_sword__SWBuf,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "AttributeTypeListMap_erase" "', argument " "2"" of type '" "std::map< sword::SWBuf,std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > > > > >::key_type const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "AttributeTypeListMap_erase" "', argument " "2"" of type '" "std::map< sword::SWBuf,std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > > > > >::key_type const &""'"); 
  }
  arg2 = reinterpret_cast< std::map< sword::SWBuf,std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > > > > >::key_type * >(argp2);
  {
    try {
      result = (arg1)->erase((std::map< sword::SWBuf,std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > > > > >::key_type const &)*arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_AttributeTypeListMap_count(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::map< sword::SWBuf,AttributeListMap > *arg1 = 0 ;
  std::map< sword::SWBuf,std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > > > > >::key_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  std::map< sword::SWBuf,std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > > > > >::size_type result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "AttributeTypeListMap_count", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_sword__SWBuf_AttributeListMap_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AttributeTypeListMap_count" "', argument " "1"" of type '" "std::map< sword::SWBuf,AttributeListMap > const *""'"); 
  }
  arg1 = reinterpret_cast< std::map< sword::SWBuf,AttributeListMap > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_sword__SWBuf,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "AttributeTypeListMap_count" "', argument " "2"" of type '" "std::map< sword::SWBuf,std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > > > > >::key_type const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "AttributeTypeListMap_count" "', argument " "2"" of type '" "std::map< sword::SWBuf,std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > > > > >::key_type const &""'"); 
  }
  arg2 = reinterpret_cast< std::map< sword::SWBuf,std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > > > > >::key_type * >(argp2);
  {
    try {
      result = ((std::map< sword::SWBuf,AttributeListMap > const *)arg1)->count((std::map< sword::SWBuf,std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > > > > >::key_type const &)*arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_AttributeTypeListMap_erase__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::map< sword::SWBuf,AttributeListMap > *arg1 = 0 ;
  SwigValueWrapper< std::map< sword::SWBuf,std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > > > > >::iterator > arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_sword__SWBuf_AttributeListMap_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AttributeTypeListMap_erase" "', argument " "1"" of type '" "std::map< sword::SWBuf,AttributeListMap > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< sword::SWBuf,AttributeListMap > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "AttributeTypeListMap_erase" "', argument " "2"" of type '" "std::map< sword::SWBuf,std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > > > > >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::map< sword::SWBuf,std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > > > > >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::map< sword::SWBuf,std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > > > > >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "AttributeTypeListMap_erase" "', argument " "2"" of type '" "std::map< sword::SWBuf,std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > > > > >::iterator""'");
    }
  }
  {
    try {
      std_map_Sl_sword_SWBuf_Sc_AttributeListMap_Sg__erase__SWIG_1(arg1,SWIG_STD_MOVE(arg2)); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_AttributeTypeListMap_erase__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::map< sword::SWBuf,AttributeListMap > *arg1 = 0 ;
  SwigValueWrapper< std::map< sword::SWBuf,std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > > > > >::iterator > arg2 ;
  SwigValueWrapper< std::map< sword::SWBuf,std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > > > > >::iterator > arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  swig::SwigPyIterator *iter3 = 0 ;
  int res3 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_sword__SWBuf_AttributeListMap_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AttributeTypeListMap_erase" "', argument " "1"" of type '" "std::map< sword::SWBuf,AttributeListMap > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< sword::SWBuf,AttributeListMap > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "AttributeTypeListMap_erase" "', argument " "2"" of type '" "std::map< sword::SWBuf,std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > > > > >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::map< sword::SWBuf,std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > > > > >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::map< sword::SWBuf,std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > > > > >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "AttributeTypeListMap_erase" "', argument " "2"" of type '" "std::map< sword::SWBuf,std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > > > > >::iterator""'");
    }
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], SWIG_as_voidptrptr(&iter3), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res3) || !iter3) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "AttributeTypeListMap_erase" "', argument " "3"" of type '" "std::map< sword::SWBuf,std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > > > > >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::map< sword::SWBuf,std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > > > > >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::map< sword::SWBuf,std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > > > > >::iterator > *>(iter3);
    if (iter_t) {
      arg3 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "AttributeTypeListMap_erase" "', argument " "3"" of type '" "std::map< sword::SWBuf,std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > > > > >::iterator""'");
    }
  }
  {
    try {
      std_map_Sl_sword_SWBuf_Sc_AttributeListMap_Sg__erase__SWIG_2(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3)); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_AttributeTypeListMap_erase(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "AttributeTypeListMap_erase", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::map< sword::SWBuf,std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > > > >,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > > > > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_sword__SWBuf, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_AttributeTypeListMap_erase__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::map< sword::SWBuf,std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > > > >,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > > > > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::map< sword::SWBuf,std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > > > > >::iterator > *>(iter) != 0));
      if (_v) {
        return _wrap_AttributeTypeListMap_erase__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::map< sword::SWBuf,std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > > > >,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > > > > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::map< sword::SWBuf,std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > > > > >::iterator > *>(iter) != 0));
      if (_v) {
        swig::SwigPyIterator *iter = 0;
        int res = SWIG_ConvertPtr(argv[2], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
        _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::map< sword::SWBuf,std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > > > > >::iterator > *>(iter) != 0));
        if (_v) {
          return _wrap_AttributeTypeListMap_erase__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'AttributeTypeListMap_erase'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::map< sword::SWBuf,AttributeListMap >::erase(std::map< sword::SWBuf,std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > > > > >::key_type const &)\n"
    "    std::map< sword::SWBuf,AttributeListMap >::erase(std::map< sword::SWBuf,std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > > > > >::iterator)\n"
    "    std::map< sword::SWBuf,AttributeListMap >::erase(std::map< sword::SWBuf,std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > > > > >::iterator,std::map< sword::SWBuf,std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > > > > >::iterator)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_AttributeTypeListMap_find(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::map< sword::SWBuf,AttributeListMap > *arg1 = 0 ;
  std::map< sword::SWBuf,std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > > > > >::key_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SwigValueWrapper< std::map< sword::SWBuf,std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > > > > >::iterator > result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "AttributeTypeListMap_find", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_sword__SWBuf_AttributeListMap_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AttributeTypeListMap_find" "', argument " "1"" of type '" "std::map< sword::SWBuf,AttributeListMap > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< sword::SWBuf,AttributeListMap > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_sword__SWBuf,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "AttributeTypeListMap_find" "', argument " "2"" of type '" "std::map< sword::SWBuf,std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > > > > >::key_type const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "AttributeTypeListMap_find" "', argument " "2"" of type '" "std::map< sword::SWBuf,std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > > > > >::key_type const &""'"); 
  }
  arg2 = reinterpret_cast< std::map< sword::SWBuf,std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > > > > >::key_type * >(argp2);
  {
    try {
      result = (arg1)->find((std::map< sword::SWBuf,std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > > > > >::key_type const &)*arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::map< sword::SWBuf,std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > > > > >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_AttributeTypeListMap_lower_bound(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::map< sword::SWBuf,AttributeListMap > *arg1 = 0 ;
  std::map< sword::SWBuf,std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > > > > >::key_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SwigValueWrapper< std::map< sword::SWBuf,std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > > > > >::iterator > result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "AttributeTypeListMap_lower_bound", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_sword__SWBuf_AttributeListMap_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AttributeTypeListMap_lower_bound" "', argument " "1"" of type '" "std::map< sword::SWBuf,AttributeListMap > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< sword::SWBuf,AttributeListMap > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_sword__SWBuf,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "AttributeTypeListMap_lower_bound" "', argument " "2"" of type '" "std::map< sword::SWBuf,std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > > > > >::key_type const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "AttributeTypeListMap_lower_bound" "', argument " "2"" of type '" "std::map< sword::SWBuf,std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > > > > >::key_type const &""'"); 
  }
  arg2 = reinterpret_cast< std::map< sword::SWBuf,std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > > > > >::key_type * >(argp2);
  {
    try {
      result = (arg1)->lower_bound((std::map< sword::SWBuf,std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > > > > >::key_type const &)*arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::map< sword::SWBuf,std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > > > > >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_AttributeTypeListMap_upper_bound(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::map< sword::SWBuf,AttributeListMap > *arg1 = 0 ;
  std::map< sword::SWBuf,std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > > > > >::key_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SwigValueWrapper< std::map< sword::SWBuf,std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > > > > >::iterator > result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "AttributeTypeListMap_upper_bound", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_sword__SWBuf_AttributeListMap_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AttributeTypeListMap_upper_bound" "', argument " "1"" of type '" "std::map< sword::SWBuf,AttributeListMap > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< sword::SWBuf,AttributeListMap > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_sword__SWBuf,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "AttributeTypeListMap_upper_bound" "', argument " "2"" of type '" "std::map< sword::SWBuf,std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > > > > >::key_type const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "AttributeTypeListMap_upper_bound" "', argument " "2"" of type '" "std::map< sword::SWBuf,std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > > > > >::key_type const &""'"); 
  }
  arg2 = reinterpret_cast< std::map< sword::SWBuf,std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > > > > >::key_type * >(argp2);
  {
    try {
      result = (arg1)->upper_bound((std::map< sword::SWBuf,std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > > > > >::key_type const &)*arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::map< sword::SWBuf,std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > > > > >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_AttributeTypeListMap(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::map< sword::SWBuf,AttributeListMap > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_sword__SWBuf_AttributeListMap_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AttributeTypeListMap" "', argument " "1"" of type '" "std::map< sword::SWBuf,AttributeListMap > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< sword::SWBuf,AttributeListMap > * >(argp1);
  {
    try {
      delete arg1; 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *AttributeTypeListMap_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__mapT_sword__SWBuf_AttributeListMap_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *AttributeTypeListMap_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_PyConfigEntMap__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::less< sword::SWBuf > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_std__lessT_sword__SWBuf_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PyConfigEntMap" "', argument " "1"" of type '" "std::less< sword::SWBuf > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_PyConfigEntMap" "', argument " "1"" of type '" "std::less< sword::SWBuf > const &""'"); 
  }
  arg1 = reinterpret_cast< std::less< sword::SWBuf > * >(argp1);
  {
    try {
      result = (std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > *)new std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > >((std::less< sword::SWBuf > const &)*arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__multimapT_sword__SWBuf_sword__SWBuf_std__lessT_sword__SWBuf_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PyConfigEntMap_iterator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > *arg1 = 0 ;
  PyObject **arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  swig::SwigPyIterator *result = 0 ;
  
  arg2 = &swig_obj[0];
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__multimapT_sword__SWBuf_sword__SWBuf_std__lessT_sword__SWBuf_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyConfigEntMap_iterator" "', argument " "1"" of type '" "std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > *""'"); 
  }
  arg1 = reinterpret_cast< std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > * >(argp1);
  {
    try {
      result = (swig::SwigPyIterator *)std_multimap_Sl_sword_SWBuf_Sc_sword_SWBuf_Sc_std_less_Sl_sword_SWBuf_Sg__Sg__iterator(arg1,arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  if (!result) SWIG_fail;
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PyConfigEntMap___nonzero__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__multimapT_sword__SWBuf_sword__SWBuf_std__lessT_sword__SWBuf_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyConfigEntMap___nonzero__" "', argument " "1"" of type '" "std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > * >(argp1);
  {
    try {
      result = (bool)std_multimap_Sl_sword_SWBuf_Sc_sword_SWBuf_Sc_std_less_Sl_sword_SWBuf_Sg__Sg____nonzero__((std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > const *)arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PyConfigEntMap___bool__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__multimapT_sword__SWBuf_sword__SWBuf_std__lessT_sword__SWBuf_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyConfigEntMap___bool__" "', argument " "1"" of type '" "std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > * >(argp1);
  {
    try {
      result = (bool)std_multimap_Sl_sword_SWBuf_Sc_sword_SWBuf_Sc_std_less_Sl_sword_SWBuf_Sg__Sg____bool__((std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > const *)arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PyConfigEntMap___len__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > >::size_type result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__multimapT_sword__SWBuf_sword__SWBuf_std__lessT_sword__SWBuf_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyConfigEntMap___len__" "', argument " "1"" of type '" "std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > * >(argp1);
  {
    try {
      result = std_multimap_Sl_sword_SWBuf_Sc_sword_SWBuf_Sc_std_less_Sl_sword_SWBuf_Sg__Sg____len__((std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > const *)arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PyConfigEntMap___getitem__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > *arg1 = 0 ;
  std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > >::key_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > >::mapped_type *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "PyConfigEntMap___getitem__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__multimapT_sword__SWBuf_sword__SWBuf_std__lessT_sword__SWBuf_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyConfigEntMap___getitem__" "', argument " "1"" of type '" "std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > *""'"); 
  }
  arg1 = reinterpret_cast< std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_sword__SWBuf,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyConfigEntMap___getitem__" "', argument " "2"" of type '" "std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > >::key_type const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "PyConfigEntMap___getitem__" "', argument " "2"" of type '" "std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > >::key_type const &""'"); 
  }
  arg2 = reinterpret_cast< std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > >::key_type * >(argp2);
  {
    try {
      try {
        result = (std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > >::mapped_type *) &std_multimap_Sl_sword_SWBuf_Sc_sword_SWBuf_Sc_std_less_Sl_sword_SWBuf_Sg__Sg____getitem__(arg1,(sword::SWBuf const &)*arg2);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__SWBuf, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PyConfigEntMap___delitem__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > *arg1 = 0 ;
  std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > >::key_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "PyConfigEntMap___delitem__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__multimapT_sword__SWBuf_sword__SWBuf_std__lessT_sword__SWBuf_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyConfigEntMap___delitem__" "', argument " "1"" of type '" "std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > *""'"); 
  }
  arg1 = reinterpret_cast< std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_sword__SWBuf,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyConfigEntMap___delitem__" "', argument " "2"" of type '" "std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > >::key_type const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "PyConfigEntMap___delitem__" "', argument " "2"" of type '" "std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > >::key_type const &""'"); 
  }
  arg2 = reinterpret_cast< std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > >::key_type * >(argp2);
  {
    try {
      try {
        std_multimap_Sl_sword_SWBuf_Sc_sword_SWBuf_Sc_std_less_Sl_sword_SWBuf_Sg__Sg____delitem__(arg1,(sword::SWBuf const &)*arg2);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PyConfigEntMap_has_key(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > *arg1 = 0 ;
  std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > >::key_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "PyConfigEntMap_has_key", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__multimapT_sword__SWBuf_sword__SWBuf_std__lessT_sword__SWBuf_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyConfigEntMap_has_key" "', argument " "1"" of type '" "std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_sword__SWBuf,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyConfigEntMap_has_key" "', argument " "2"" of type '" "std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > >::key_type const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "PyConfigEntMap_has_key" "', argument " "2"" of type '" "std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > >::key_type const &""'"); 
  }
  arg2 = reinterpret_cast< std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > >::key_type * >(argp2);
  {
    try {
      result = (bool)std_multimap_Sl_sword_SWBuf_Sc_sword_SWBuf_Sc_std_less_Sl_sword_SWBuf_Sg__Sg__has_key((std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > const *)arg1,(sword::SWBuf const &)*arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PyConfigEntMap_keys(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__multimapT_sword__SWBuf_sword__SWBuf_std__lessT_sword__SWBuf_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyConfigEntMap_keys" "', argument " "1"" of type '" "std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > *""'"); 
  }
  arg1 = reinterpret_cast< std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > * >(argp1);
  {
    try {
      result = (PyObject *)std_multimap_Sl_sword_SWBuf_Sc_sword_SWBuf_Sc_std_less_Sl_sword_SWBuf_Sg__Sg__keys(arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = result;
  if (!resultobj) SWIG_fail;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PyConfigEntMap_values(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__multimapT_sword__SWBuf_sword__SWBuf_std__lessT_sword__SWBuf_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyConfigEntMap_values" "', argument " "1"" of type '" "std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > *""'"); 
  }
  arg1 = reinterpret_cast< std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > * >(argp1);
  {
    try {
      result = (PyObject *)std_multimap_Sl_sword_SWBuf_Sc_sword_SWBuf_Sc_std_less_Sl_sword_SWBuf_Sg__Sg__values(arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = result;
  if (!resultobj) SWIG_fail;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PyConfigEntMap_items(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__multimapT_sword__SWBuf_sword__SWBuf_std__lessT_sword__SWBuf_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyConfigEntMap_items" "', argument " "1"" of type '" "std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > *""'"); 
  }
  arg1 = reinterpret_cast< std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > * >(argp1);
  {
    try {
      result = (PyObject *)std_multimap_Sl_sword_SWBuf_Sc_sword_SWBuf_Sc_std_less_Sl_sword_SWBuf_Sg__Sg__items(arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = result;
  if (!resultobj) SWIG_fail;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PyConfigEntMap___contains__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > *arg1 = 0 ;
  std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > >::key_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "PyConfigEntMap___contains__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__multimapT_sword__SWBuf_sword__SWBuf_std__lessT_sword__SWBuf_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyConfigEntMap___contains__" "', argument " "1"" of type '" "std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > *""'"); 
  }
  arg1 = reinterpret_cast< std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_sword__SWBuf,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyConfigEntMap___contains__" "', argument " "2"" of type '" "std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > >::key_type const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "PyConfigEntMap___contains__" "', argument " "2"" of type '" "std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > >::key_type const &""'"); 
  }
  arg2 = reinterpret_cast< std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > >::key_type * >(argp2);
  {
    try {
      result = (bool)std_multimap_Sl_sword_SWBuf_Sc_sword_SWBuf_Sc_std_less_Sl_sword_SWBuf_Sg__Sg____contains__(arg1,(sword::SWBuf const &)*arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PyConfigEntMap_key_iterator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > *arg1 = 0 ;
  PyObject **arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  swig::SwigPyIterator *result = 0 ;
  
  arg2 = &swig_obj[0];
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__multimapT_sword__SWBuf_sword__SWBuf_std__lessT_sword__SWBuf_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyConfigEntMap_key_iterator" "', argument " "1"" of type '" "std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > *""'"); 
  }
  arg1 = reinterpret_cast< std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > * >(argp1);
  {
    try {
      result = (swig::SwigPyIterator *)std_multimap_Sl_sword_SWBuf_Sc_sword_SWBuf_Sc_std_less_Sl_sword_SWBuf_Sg__Sg__key_iterator(arg1,arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  if (!result) SWIG_fail;
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PyConfigEntMap_value_iterator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > *arg1 = 0 ;
  PyObject **arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  swig::SwigPyIterator *result = 0 ;
  
  arg2 = &swig_obj[0];
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__multimapT_sword__SWBuf_sword__SWBuf_std__lessT_sword__SWBuf_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyConfigEntMap_value_iterator" "', argument " "1"" of type '" "std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > *""'"); 
  }
  arg1 = reinterpret_cast< std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > * >(argp1);
  {
    try {
      result = (swig::SwigPyIterator *)std_multimap_Sl_sword_SWBuf_Sc_sword_SWBuf_Sc_std_less_Sl_sword_SWBuf_Sg__Sg__value_iterator(arg1,arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  if (!result) SWIG_fail;
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PyConfigEntMap___setitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > *arg1 = 0 ;
  std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > >::key_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__multimapT_sword__SWBuf_sword__SWBuf_std__lessT_sword__SWBuf_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyConfigEntMap___setitem__" "', argument " "1"" of type '" "std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > *""'"); 
  }
  arg1 = reinterpret_cast< std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_sword__SWBuf,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyConfigEntMap___setitem__" "', argument " "2"" of type '" "std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > >::key_type const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "PyConfigEntMap___setitem__" "', argument " "2"" of type '" "std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > >::key_type const &""'"); 
  }
  arg2 = reinterpret_cast< std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > >::key_type * >(argp2);
  {
    try {
      std_multimap_Sl_sword_SWBuf_Sc_sword_SWBuf_Sc_std_less_Sl_sword_SWBuf_Sg__Sg____setitem____SWIG_0(arg1,(sword::SWBuf const &)*arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PyConfigEntMap___setitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > *arg1 = 0 ;
  std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > >::key_type *arg2 = 0 ;
  std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > >::mapped_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__multimapT_sword__SWBuf_sword__SWBuf_std__lessT_sword__SWBuf_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyConfigEntMap___setitem__" "', argument " "1"" of type '" "std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > *""'"); 
  }
  arg1 = reinterpret_cast< std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_sword__SWBuf,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyConfigEntMap___setitem__" "', argument " "2"" of type '" "std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > >::key_type const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "PyConfigEntMap___setitem__" "', argument " "2"" of type '" "std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > >::key_type const &""'"); 
  }
  arg2 = reinterpret_cast< std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > >::key_type * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_sword__SWBuf,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PyConfigEntMap___setitem__" "', argument " "3"" of type '" "std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > >::mapped_type const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "PyConfigEntMap___setitem__" "', argument " "3"" of type '" "std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > >::mapped_type const &""'"); 
  }
  arg3 = reinterpret_cast< std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > >::mapped_type * >(argp3);
  {
    try {
      try {
        std_multimap_Sl_sword_SWBuf_Sc_sword_SWBuf_Sc_std_less_Sl_sword_SWBuf_Sg__Sg____setitem____SWIG_1(arg1,(sword::SWBuf const &)*arg2,(sword::SWBuf const &)*arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PyConfigEntMap___setitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "PyConfigEntMap___setitem__", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_sword__SWBuf, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_PyConfigEntMap___setitem____SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_sword__SWBuf, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_sword__SWBuf, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_PyConfigEntMap___setitem____SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PyConfigEntMap___setitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > >::__setitem__(std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > >::key_type const &)\n"
    "    std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > >::__setitem__(std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > >::key_type const &,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > >::mapped_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_new_PyConfigEntMap__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > *)new std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > >(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__multimapT_sword__SWBuf_sword__SWBuf_std__lessT_sword__SWBuf_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PyConfigEntMap__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > *ptr = (std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PyConfigEntMap" "', argument " "1"" of type '" "std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_PyConfigEntMap" "', argument " "1"" of type '" "std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > const &""'"); 
    }
    arg1 = ptr;
  }
  {
    try {
      result = (std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > *)new std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > >((std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > const &)*arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__multimapT_sword__SWBuf_sword__SWBuf_std__lessT_sword__SWBuf_t_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PyConfigEntMap(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_PyConfigEntMap", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_PyConfigEntMap__SWIG_1(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_std__lessT_sword__SWBuf_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_PyConfigEntMap__SWIG_0(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_PyConfigEntMap__SWIG_2(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_PyConfigEntMap'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > >::multimap(std::less< sword::SWBuf > const &)\n"
    "    std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > >::multimap()\n"
    "    std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > >::multimap(std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_PyConfigEntMap_empty(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__multimapT_sword__SWBuf_sword__SWBuf_std__lessT_sword__SWBuf_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyConfigEntMap_empty" "', argument " "1"" of type '" "std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > * >(argp1);
  {
    try {
      result = (bool)((std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > const *)arg1)->empty(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PyConfigEntMap_size(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > >::size_type result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__multimapT_sword__SWBuf_sword__SWBuf_std__lessT_sword__SWBuf_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyConfigEntMap_size" "', argument " "1"" of type '" "std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > * >(argp1);
  {
    try {
      result = ((std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > const *)arg1)->size(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PyConfigEntMap_swap(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > *arg1 = 0 ;
  std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "PyConfigEntMap_swap", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__multimapT_sword__SWBuf_sword__SWBuf_std__lessT_sword__SWBuf_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyConfigEntMap_swap" "', argument " "1"" of type '" "std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > *""'"); 
  }
  arg1 = reinterpret_cast< std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__multimapT_sword__SWBuf_sword__SWBuf_std__lessT_sword__SWBuf_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyConfigEntMap_swap" "', argument " "2"" of type '" "std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "PyConfigEntMap_swap" "', argument " "2"" of type '" "std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > &""'"); 
  }
  arg2 = reinterpret_cast< std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > * >(argp2);
  {
    try {
      (arg1)->swap(*arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PyConfigEntMap_begin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > >::iterator result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__multimapT_sword__SWBuf_sword__SWBuf_std__lessT_sword__SWBuf_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyConfigEntMap_begin" "', argument " "1"" of type '" "std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > *""'"); 
  }
  arg1 = reinterpret_cast< std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > * >(argp1);
  {
    try {
      result = (arg1)->begin(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PyConfigEntMap_end(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > >::iterator result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__multimapT_sword__SWBuf_sword__SWBuf_std__lessT_sword__SWBuf_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyConfigEntMap_end" "', argument " "1"" of type '" "std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > *""'"); 
  }
  arg1 = reinterpret_cast< std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > * >(argp1);
  {
    try {
      result = (arg1)->end(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PyConfigEntMap_rbegin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > >::reverse_iterator result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__multimapT_sword__SWBuf_sword__SWBuf_std__lessT_sword__SWBuf_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyConfigEntMap_rbegin" "', argument " "1"" of type '" "std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > *""'"); 
  }
  arg1 = reinterpret_cast< std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > * >(argp1);
  {
    try {
      result = (arg1)->rbegin(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > >::reverse_iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PyConfigEntMap_rend(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > >::reverse_iterator result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__multimapT_sword__SWBuf_sword__SWBuf_std__lessT_sword__SWBuf_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyConfigEntMap_rend" "', argument " "1"" of type '" "std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > *""'"); 
  }
  arg1 = reinterpret_cast< std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > * >(argp1);
  {
    try {
      result = (arg1)->rend(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > >::reverse_iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PyConfigEntMap_clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__multimapT_sword__SWBuf_sword__SWBuf_std__lessT_sword__SWBuf_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyConfigEntMap_clear" "', argument " "1"" of type '" "std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > *""'"); 
  }
  arg1 = reinterpret_cast< std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > * >(argp1);
  {
    try {
      (arg1)->clear(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PyConfigEntMap_get_allocator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__multimapT_sword__SWBuf_sword__SWBuf_std__lessT_sword__SWBuf_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyConfigEntMap_get_allocator" "', argument " "1"" of type '" "std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > * >(argp1);
  {
    try {
      result = ((std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > const *)arg1)->get_allocator(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj((new std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > >::allocator_type(result)), SWIGTYPE_p_std__allocatorT_std__pairT_sword__SWBuf_const_sword__SWBuf_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PyConfigEntMap_erase__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > *arg1 = 0 ;
  std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > >::key_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > >::size_type result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__multimapT_sword__SWBuf_sword__SWBuf_std__lessT_sword__SWBuf_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyConfigEntMap_erase" "', argument " "1"" of type '" "std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > *""'"); 
  }
  arg1 = reinterpret_cast< std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_sword__SWBuf,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyConfigEntMap_erase" "', argument " "2"" of type '" "std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > >::key_type const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "PyConfigEntMap_erase" "', argument " "2"" of type '" "std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > >::key_type const &""'"); 
  }
  arg2 = reinterpret_cast< std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > >::key_type * >(argp2);
  {
    try {
      result = (arg1)->erase((std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > >::key_type const &)*arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PyConfigEntMap_count(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > *arg1 = 0 ;
  std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > >::key_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > >::size_type result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "PyConfigEntMap_count", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__multimapT_sword__SWBuf_sword__SWBuf_std__lessT_sword__SWBuf_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyConfigEntMap_count" "', argument " "1"" of type '" "std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_sword__SWBuf,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyConfigEntMap_count" "', argument " "2"" of type '" "std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > >::key_type const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "PyConfigEntMap_count" "', argument " "2"" of type '" "std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > >::key_type const &""'"); 
  }
  arg2 = reinterpret_cast< std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > >::key_type * >(argp2);
  {
    try {
      result = ((std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > const *)arg1)->count((std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > >::key_type const &)*arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PyConfigEntMap_erase__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > *arg1 = 0 ;
  std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > >::iterator arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__multimapT_sword__SWBuf_sword__SWBuf_std__lessT_sword__SWBuf_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyConfigEntMap_erase" "', argument " "1"" of type '" "std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > *""'"); 
  }
  arg1 = reinterpret_cast< std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "PyConfigEntMap_erase" "', argument " "2"" of type '" "std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "PyConfigEntMap_erase" "', argument " "2"" of type '" "std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > >::iterator""'");
    }
  }
  {
    try {
      std_multimap_Sl_sword_SWBuf_Sc_sword_SWBuf_Sc_std_less_Sl_sword_SWBuf_Sg__Sg__erase__SWIG_1(arg1,SWIG_STD_MOVE(arg2)); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PyConfigEntMap_erase__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > *arg1 = 0 ;
  std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > >::iterator arg2 ;
  std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > >::iterator arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  swig::SwigPyIterator *iter3 = 0 ;
  int res3 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__multimapT_sword__SWBuf_sword__SWBuf_std__lessT_sword__SWBuf_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyConfigEntMap_erase" "', argument " "1"" of type '" "std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > *""'"); 
  }
  arg1 = reinterpret_cast< std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "PyConfigEntMap_erase" "', argument " "2"" of type '" "std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "PyConfigEntMap_erase" "', argument " "2"" of type '" "std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > >::iterator""'");
    }
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], SWIG_as_voidptrptr(&iter3), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res3) || !iter3) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "PyConfigEntMap_erase" "', argument " "3"" of type '" "std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > >::iterator > *>(iter3);
    if (iter_t) {
      arg3 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "PyConfigEntMap_erase" "', argument " "3"" of type '" "std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > >::iterator""'");
    }
  }
  {
    try {
      std_multimap_Sl_sword_SWBuf_Sc_sword_SWBuf_Sc_std_less_Sl_sword_SWBuf_Sg__Sg__erase__SWIG_2(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3)); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PyConfigEntMap_erase(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "PyConfigEntMap_erase", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_sword__SWBuf, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_PyConfigEntMap_erase__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > >::iterator > *>(iter) != 0));
      if (_v) {
        return _wrap_PyConfigEntMap_erase__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > >::iterator > *>(iter) != 0));
      if (_v) {
        swig::SwigPyIterator *iter = 0;
        int res = SWIG_ConvertPtr(argv[2], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
        _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > >::iterator > *>(iter) != 0));
        if (_v) {
          return _wrap_PyConfigEntMap_erase__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PyConfigEntMap_erase'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > >::erase(std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > >::key_type const &)\n"
    "    std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > >::erase(std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > >::iterator)\n"
    "    std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > >::erase(std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > >::iterator,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > >::iterator)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_PyConfigEntMap_find(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > *arg1 = 0 ;
  std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > >::key_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > >::iterator result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "PyConfigEntMap_find", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__multimapT_sword__SWBuf_sword__SWBuf_std__lessT_sword__SWBuf_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyConfigEntMap_find" "', argument " "1"" of type '" "std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > *""'"); 
  }
  arg1 = reinterpret_cast< std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_sword__SWBuf,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyConfigEntMap_find" "', argument " "2"" of type '" "std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > >::key_type const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "PyConfigEntMap_find" "', argument " "2"" of type '" "std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > >::key_type const &""'"); 
  }
  arg2 = reinterpret_cast< std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > >::key_type * >(argp2);
  {
    try {
      result = (arg1)->find((std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > >::key_type const &)*arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PyConfigEntMap_lower_bound(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > *arg1 = 0 ;
  std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > >::key_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > >::iterator result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "PyConfigEntMap_lower_bound", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__multimapT_sword__SWBuf_sword__SWBuf_std__lessT_sword__SWBuf_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyConfigEntMap_lower_bound" "', argument " "1"" of type '" "std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > *""'"); 
  }
  arg1 = reinterpret_cast< std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_sword__SWBuf,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyConfigEntMap_lower_bound" "', argument " "2"" of type '" "std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > >::key_type const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "PyConfigEntMap_lower_bound" "', argument " "2"" of type '" "std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > >::key_type const &""'"); 
  }
  arg2 = reinterpret_cast< std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > >::key_type * >(argp2);
  {
    try {
      result = (arg1)->lower_bound((std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > >::key_type const &)*arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PyConfigEntMap_upper_bound(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > *arg1 = 0 ;
  std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > >::key_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > >::iterator result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "PyConfigEntMap_upper_bound", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__multimapT_sword__SWBuf_sword__SWBuf_std__lessT_sword__SWBuf_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyConfigEntMap_upper_bound" "', argument " "1"" of type '" "std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > *""'"); 
  }
  arg1 = reinterpret_cast< std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_sword__SWBuf,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyConfigEntMap_upper_bound" "', argument " "2"" of type '" "std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > >::key_type const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "PyConfigEntMap_upper_bound" "', argument " "2"" of type '" "std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > >::key_type const &""'"); 
  }
  arg2 = reinterpret_cast< std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > >::key_type * >(argp2);
  {
    try {
      result = (arg1)->upper_bound((std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > >::key_type const &)*arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PyConfigEntMap_equal_range__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > *arg1 = 0 ;
  std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > >::key_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  SwigValueWrapper< std::pair< std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > >::iterator,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > >::iterator > > result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__multimapT_sword__SWBuf_sword__SWBuf_std__lessT_sword__SWBuf_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyConfigEntMap_equal_range" "', argument " "1"" of type '" "std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > *""'"); 
  }
  arg1 = reinterpret_cast< std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_sword__SWBuf,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyConfigEntMap_equal_range" "', argument " "2"" of type '" "std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > >::key_type const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "PyConfigEntMap_equal_range" "', argument " "2"" of type '" "std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > >::key_type const &""'"); 
  }
  arg2 = reinterpret_cast< std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > >::key_type * >(argp2);
  {
    try {
      result = (arg1)->equal_range((std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > >::key_type const &)*arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = PyTuple_New(2);
  PyTuple_SetItem(resultobj,0,SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::pair< std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > >::iterator,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > >::iterator > & >(result).first),
      swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN));
  PyTuple_SetItem(resultobj,1,SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::pair< std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > >::iterator,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > >::iterator > & >(result).second),
      swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PyConfigEntMap_equal_range__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > *arg1 = 0 ;
  std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > >::key_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  SwigValueWrapper< std::pair< std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > >::const_iterator,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > >::const_iterator > > result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__multimapT_sword__SWBuf_sword__SWBuf_std__lessT_sword__SWBuf_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyConfigEntMap_equal_range" "', argument " "1"" of type '" "std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_sword__SWBuf,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyConfigEntMap_equal_range" "', argument " "2"" of type '" "std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > >::key_type const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "PyConfigEntMap_equal_range" "', argument " "2"" of type '" "std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > >::key_type const &""'"); 
  }
  arg2 = reinterpret_cast< std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > >::key_type * >(argp2);
  {
    try {
      result = ((std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > const *)arg1)->equal_range((std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > >::key_type const &)*arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = PyTuple_New(2);
  PyTuple_SetItem(resultobj,0,SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::pair< std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > >::const_iterator,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > >::const_iterator > & >(result).first),
      swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN));
  PyTuple_SetItem(resultobj,1,SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::pair< std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > >::const_iterator,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > >::const_iterator > & >(result).second),
      swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PyConfigEntMap_equal_range(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "PyConfigEntMap_equal_range", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_sword__SWBuf, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_PyConfigEntMap_equal_range__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_sword__SWBuf, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_PyConfigEntMap_equal_range__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PyConfigEntMap_equal_range'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > >::equal_range(std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > >::key_type const &)\n"
    "    std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > >::equal_range(std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > >::key_type const &) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_PyConfigEntMap(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__multimapT_sword__SWBuf_sword__SWBuf_std__lessT_sword__SWBuf_t_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyConfigEntMap" "', argument " "1"" of type '" "std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > *""'"); 
  }
  arg1 = reinterpret_cast< std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > * >(argp1);
  {
    try {
      delete arg1; 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *PyConfigEntMap_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__multimapT_sword__SWBuf_sword__SWBuf_std__lessT_sword__SWBuf_t_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *PyConfigEntMap_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_PySectionMap__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::less< sword::SWBuf > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > > *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_std__lessT_sword__SWBuf_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PySectionMap" "', argument " "1"" of type '" "std::less< sword::SWBuf > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_PySectionMap" "', argument " "1"" of type '" "std::less< sword::SWBuf > const &""'"); 
  }
  arg1 = reinterpret_cast< std::less< sword::SWBuf > * >(argp1);
  {
    try {
      result = (std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > > *)new std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > >((std::less< sword::SWBuf > const &)*arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__mapT_sword__SWBuf_std__multimapT_sword__SWBuf_sword__SWBuf_std__lessT_sword__SWBuf_t_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PySectionMap_iterator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > > *arg1 = 0 ;
  PyObject **arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  swig::SwigPyIterator *result = 0 ;
  
  arg2 = &swig_obj[0];
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_sword__SWBuf_std__multimapT_sword__SWBuf_sword__SWBuf_std__lessT_sword__SWBuf_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySectionMap_iterator" "', argument " "1"" of type '" "std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > > * >(argp1);
  {
    try {
      result = (swig::SwigPyIterator *)std_map_Sl_sword_SWBuf_Sc_std_multimap_Sl_sword_SWBuf_Sc_sword_SWBuf_Sc_std_less_Sl_sword_SWBuf_Sg__Sg__Sg__iterator(arg1,arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  if (!result) SWIG_fail;
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PySectionMap___nonzero__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_sword__SWBuf_std__multimapT_sword__SWBuf_sword__SWBuf_std__lessT_sword__SWBuf_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySectionMap___nonzero__" "', argument " "1"" of type '" "std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > > * >(argp1);
  {
    try {
      result = (bool)std_map_Sl_sword_SWBuf_Sc_std_multimap_Sl_sword_SWBuf_Sc_sword_SWBuf_Sc_std_less_Sl_sword_SWBuf_Sg__Sg__Sg____nonzero__((std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > > const *)arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PySectionMap___bool__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_sword__SWBuf_std__multimapT_sword__SWBuf_sword__SWBuf_std__lessT_sword__SWBuf_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySectionMap___bool__" "', argument " "1"" of type '" "std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > > * >(argp1);
  {
    try {
      result = (bool)std_map_Sl_sword_SWBuf_Sc_std_multimap_Sl_sword_SWBuf_Sc_sword_SWBuf_Sc_std_less_Sl_sword_SWBuf_Sg__Sg__Sg____bool__((std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > > const *)arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PySectionMap___len__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > >::size_type result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_sword__SWBuf_std__multimapT_sword__SWBuf_sword__SWBuf_std__lessT_sword__SWBuf_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySectionMap___len__" "', argument " "1"" of type '" "std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > > * >(argp1);
  {
    try {
      result = std_map_Sl_sword_SWBuf_Sc_std_multimap_Sl_sword_SWBuf_Sc_sword_SWBuf_Sc_std_less_Sl_sword_SWBuf_Sg__Sg__Sg____len__((std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > > const *)arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PySectionMap___getitem__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > > *arg1 = 0 ;
  std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > >::key_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > >::mapped_type *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "PySectionMap___getitem__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_sword__SWBuf_std__multimapT_sword__SWBuf_sword__SWBuf_std__lessT_sword__SWBuf_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySectionMap___getitem__" "', argument " "1"" of type '" "std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_sword__SWBuf,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PySectionMap___getitem__" "', argument " "2"" of type '" "std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > >::key_type const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "PySectionMap___getitem__" "', argument " "2"" of type '" "std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > >::key_type const &""'"); 
  }
  arg2 = reinterpret_cast< std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > >::key_type * >(argp2);
  {
    try {
      try {
        result = (std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > >::mapped_type *) &std_map_Sl_sword_SWBuf_Sc_std_multimap_Sl_sword_SWBuf_Sc_sword_SWBuf_Sc_std_less_Sl_sword_SWBuf_Sg__Sg__Sg____getitem__(arg1,(sword::SWBuf const &)*arg2);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = swig::from(static_cast< std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PySectionMap___delitem__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > > *arg1 = 0 ;
  std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > >::key_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "PySectionMap___delitem__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_sword__SWBuf_std__multimapT_sword__SWBuf_sword__SWBuf_std__lessT_sword__SWBuf_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySectionMap___delitem__" "', argument " "1"" of type '" "std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_sword__SWBuf,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PySectionMap___delitem__" "', argument " "2"" of type '" "std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > >::key_type const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "PySectionMap___delitem__" "', argument " "2"" of type '" "std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > >::key_type const &""'"); 
  }
  arg2 = reinterpret_cast< std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > >::key_type * >(argp2);
  {
    try {
      try {
        std_map_Sl_sword_SWBuf_Sc_std_multimap_Sl_sword_SWBuf_Sc_sword_SWBuf_Sc_std_less_Sl_sword_SWBuf_Sg__Sg__Sg____delitem__(arg1,(sword::SWBuf const &)*arg2);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PySectionMap_has_key(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > > *arg1 = 0 ;
  std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > >::key_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "PySectionMap_has_key", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_sword__SWBuf_std__multimapT_sword__SWBuf_sword__SWBuf_std__lessT_sword__SWBuf_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySectionMap_has_key" "', argument " "1"" of type '" "std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_sword__SWBuf,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PySectionMap_has_key" "', argument " "2"" of type '" "std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > >::key_type const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "PySectionMap_has_key" "', argument " "2"" of type '" "std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > >::key_type const &""'"); 
  }
  arg2 = reinterpret_cast< std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > >::key_type * >(argp2);
  {
    try {
      result = (bool)std_map_Sl_sword_SWBuf_Sc_std_multimap_Sl_sword_SWBuf_Sc_sword_SWBuf_Sc_std_less_Sl_sword_SWBuf_Sg__Sg__Sg__has_key((std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > > const *)arg1,(sword::SWBuf const &)*arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PySectionMap_keys(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_sword__SWBuf_std__multimapT_sword__SWBuf_sword__SWBuf_std__lessT_sword__SWBuf_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySectionMap_keys" "', argument " "1"" of type '" "std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > > * >(argp1);
  {
    try {
      result = (PyObject *)std_map_Sl_sword_SWBuf_Sc_std_multimap_Sl_sword_SWBuf_Sc_sword_SWBuf_Sc_std_less_Sl_sword_SWBuf_Sg__Sg__Sg__keys(arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = result;
  if (!resultobj) SWIG_fail;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PySectionMap_values(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_sword__SWBuf_std__multimapT_sword__SWBuf_sword__SWBuf_std__lessT_sword__SWBuf_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySectionMap_values" "', argument " "1"" of type '" "std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > > * >(argp1);
  {
    try {
      result = (PyObject *)std_map_Sl_sword_SWBuf_Sc_std_multimap_Sl_sword_SWBuf_Sc_sword_SWBuf_Sc_std_less_Sl_sword_SWBuf_Sg__Sg__Sg__values(arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = result;
  if (!resultobj) SWIG_fail;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PySectionMap_items(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_sword__SWBuf_std__multimapT_sword__SWBuf_sword__SWBuf_std__lessT_sword__SWBuf_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySectionMap_items" "', argument " "1"" of type '" "std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > > * >(argp1);
  {
    try {
      result = (PyObject *)std_map_Sl_sword_SWBuf_Sc_std_multimap_Sl_sword_SWBuf_Sc_sword_SWBuf_Sc_std_less_Sl_sword_SWBuf_Sg__Sg__Sg__items(arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = result;
  if (!resultobj) SWIG_fail;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PySectionMap___contains__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > > *arg1 = 0 ;
  std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > >::key_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "PySectionMap___contains__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_sword__SWBuf_std__multimapT_sword__SWBuf_sword__SWBuf_std__lessT_sword__SWBuf_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySectionMap___contains__" "', argument " "1"" of type '" "std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_sword__SWBuf,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PySectionMap___contains__" "', argument " "2"" of type '" "std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > >::key_type const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "PySectionMap___contains__" "', argument " "2"" of type '" "std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > >::key_type const &""'"); 
  }
  arg2 = reinterpret_cast< std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > >::key_type * >(argp2);
  {
    try {
      result = (bool)std_map_Sl_sword_SWBuf_Sc_std_multimap_Sl_sword_SWBuf_Sc_sword_SWBuf_Sc_std_less_Sl_sword_SWBuf_Sg__Sg__Sg____contains__(arg1,(sword::SWBuf const &)*arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PySectionMap_key_iterator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > > *arg1 = 0 ;
  PyObject **arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  swig::SwigPyIterator *result = 0 ;
  
  arg2 = &swig_obj[0];
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_sword__SWBuf_std__multimapT_sword__SWBuf_sword__SWBuf_std__lessT_sword__SWBuf_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySectionMap_key_iterator" "', argument " "1"" of type '" "std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > > * >(argp1);
  {
    try {
      result = (swig::SwigPyIterator *)std_map_Sl_sword_SWBuf_Sc_std_multimap_Sl_sword_SWBuf_Sc_sword_SWBuf_Sc_std_less_Sl_sword_SWBuf_Sg__Sg__Sg__key_iterator(arg1,arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  if (!result) SWIG_fail;
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PySectionMap_value_iterator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > > *arg1 = 0 ;
  PyObject **arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  swig::SwigPyIterator *result = 0 ;
  
  arg2 = &swig_obj[0];
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_sword__SWBuf_std__multimapT_sword__SWBuf_sword__SWBuf_std__lessT_sword__SWBuf_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySectionMap_value_iterator" "', argument " "1"" of type '" "std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > > * >(argp1);
  {
    try {
      result = (swig::SwigPyIterator *)std_map_Sl_sword_SWBuf_Sc_std_multimap_Sl_sword_SWBuf_Sc_sword_SWBuf_Sc_std_less_Sl_sword_SWBuf_Sg__Sg__Sg__value_iterator(arg1,arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  if (!result) SWIG_fail;
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PySectionMap___setitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > > *arg1 = 0 ;
  std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > >::key_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_sword__SWBuf_std__multimapT_sword__SWBuf_sword__SWBuf_std__lessT_sword__SWBuf_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySectionMap___setitem__" "', argument " "1"" of type '" "std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_sword__SWBuf,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PySectionMap___setitem__" "', argument " "2"" of type '" "std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > >::key_type const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "PySectionMap___setitem__" "', argument " "2"" of type '" "std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > >::key_type const &""'"); 
  }
  arg2 = reinterpret_cast< std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > >::key_type * >(argp2);
  {
    try {
      std_map_Sl_sword_SWBuf_Sc_std_multimap_Sl_sword_SWBuf_Sc_sword_SWBuf_Sc_std_less_Sl_sword_SWBuf_Sg__Sg__Sg____setitem____SWIG_0(arg1,(sword::SWBuf const &)*arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PySectionMap___setitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > > *arg1 = 0 ;
  std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > >::key_type *arg2 = 0 ;
  std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > >::mapped_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_sword__SWBuf_std__multimapT_sword__SWBuf_sword__SWBuf_std__lessT_sword__SWBuf_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySectionMap___setitem__" "', argument " "1"" of type '" "std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_sword__SWBuf,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PySectionMap___setitem__" "', argument " "2"" of type '" "std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > >::key_type const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "PySectionMap___setitem__" "', argument " "2"" of type '" "std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > >::key_type const &""'"); 
  }
  arg2 = reinterpret_cast< std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > >::key_type * >(argp2);
  {
    std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > *ptr = (std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PySectionMap___setitem__" "', argument " "3"" of type '" "std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > >::mapped_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "PySectionMap___setitem__" "', argument " "3"" of type '" "std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > >::mapped_type const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      try {
        std_map_Sl_sword_SWBuf_Sc_std_multimap_Sl_sword_SWBuf_Sc_sword_SWBuf_Sc_std_less_Sl_sword_SWBuf_Sg__Sg__Sg____setitem____SWIG_1(arg1,(sword::SWBuf const &)*arg2,(std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > const &)*arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_PySectionMap___setitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "PySectionMap___setitem__", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_sword__SWBuf, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_PySectionMap___setitem____SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_sword__SWBuf, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_PySectionMap___setitem____SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PySectionMap___setitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > >::__setitem__(std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > >::key_type const &)\n"
    "    std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > >::__setitem__(std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > >::key_type const &,std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > >::mapped_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_PySectionMap_asdict(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_sword__SWBuf_std__multimapT_sword__SWBuf_sword__SWBuf_std__lessT_sword__SWBuf_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySectionMap_asdict" "', argument " "1"" of type '" "std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > > * >(argp1);
  {
    try {
      result = (PyObject *)std_map_Sl_sword_SWBuf_Sc_std_multimap_Sl_sword_SWBuf_Sc_sword_SWBuf_Sc_std_less_Sl_sword_SWBuf_Sg__Sg__Sg__asdict(arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = result;
  if (!resultobj) SWIG_fail;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PySectionMap__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > > *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > > *)new std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > >(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__mapT_sword__SWBuf_std__multimapT_sword__SWBuf_sword__SWBuf_std__lessT_sword__SWBuf_t_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PySectionMap__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > > *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > > *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > > > > *ptr = (std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > > > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PySectionMap" "', argument " "1"" of type '" "std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_PySectionMap" "', argument " "1"" of type '" "std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > > const &""'"); 
    }
    arg1 = ptr;
  }
  {
    try {
      result = (std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > > *)new std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > >((std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > > const &)*arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__mapT_sword__SWBuf_std__multimapT_sword__SWBuf_sword__SWBuf_std__lessT_sword__SWBuf_t_t_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PySectionMap(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_PySectionMap", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_PySectionMap__SWIG_1(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_std__lessT_sword__SWBuf_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_PySectionMap__SWIG_0(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_PySectionMap__SWIG_2(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_PySectionMap'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > >::map(std::less< sword::SWBuf > const &)\n"
    "    std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > >::map()\n"
    "    std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > >::map(std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_PySectionMap_empty(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_sword__SWBuf_std__multimapT_sword__SWBuf_sword__SWBuf_std__lessT_sword__SWBuf_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySectionMap_empty" "', argument " "1"" of type '" "std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > > * >(argp1);
  {
    try {
      result = (bool)((std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > > const *)arg1)->empty(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PySectionMap_size(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > >::size_type result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_sword__SWBuf_std__multimapT_sword__SWBuf_sword__SWBuf_std__lessT_sword__SWBuf_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySectionMap_size" "', argument " "1"" of type '" "std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > > * >(argp1);
  {
    try {
      result = ((std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > > const *)arg1)->size(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PySectionMap_swap(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > > *arg1 = 0 ;
  std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "PySectionMap_swap", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_sword__SWBuf_std__multimapT_sword__SWBuf_sword__SWBuf_std__lessT_sword__SWBuf_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySectionMap_swap" "', argument " "1"" of type '" "std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__mapT_sword__SWBuf_std__multimapT_sword__SWBuf_sword__SWBuf_std__lessT_sword__SWBuf_t_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PySectionMap_swap" "', argument " "2"" of type '" "std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "PySectionMap_swap" "', argument " "2"" of type '" "std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > > &""'"); 
  }
  arg2 = reinterpret_cast< std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > > * >(argp2);
  {
    try {
      (arg1)->swap(*arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PySectionMap_begin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > >::iterator result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_sword__SWBuf_std__multimapT_sword__SWBuf_sword__SWBuf_std__lessT_sword__SWBuf_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySectionMap_begin" "', argument " "1"" of type '" "std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > > * >(argp1);
  {
    try {
      result = (arg1)->begin(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PySectionMap_end(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > >::iterator result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_sword__SWBuf_std__multimapT_sword__SWBuf_sword__SWBuf_std__lessT_sword__SWBuf_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySectionMap_end" "', argument " "1"" of type '" "std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > > * >(argp1);
  {
    try {
      result = (arg1)->end(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PySectionMap_rbegin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > >::reverse_iterator result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_sword__SWBuf_std__multimapT_sword__SWBuf_sword__SWBuf_std__lessT_sword__SWBuf_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySectionMap_rbegin" "', argument " "1"" of type '" "std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > > * >(argp1);
  {
    try {
      result = (arg1)->rbegin(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > >::reverse_iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PySectionMap_rend(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > >::reverse_iterator result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_sword__SWBuf_std__multimapT_sword__SWBuf_sword__SWBuf_std__lessT_sword__SWBuf_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySectionMap_rend" "', argument " "1"" of type '" "std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > > * >(argp1);
  {
    try {
      result = (arg1)->rend(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > >::reverse_iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PySectionMap_clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_sword__SWBuf_std__multimapT_sword__SWBuf_sword__SWBuf_std__lessT_sword__SWBuf_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySectionMap_clear" "', argument " "1"" of type '" "std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > > * >(argp1);
  {
    try {
      (arg1)->clear(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PySectionMap_get_allocator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< std::allocator< std::pair< sword::SWBuf const,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > > > > result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_sword__SWBuf_std__multimapT_sword__SWBuf_sword__SWBuf_std__lessT_sword__SWBuf_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySectionMap_get_allocator" "', argument " "1"" of type '" "std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > > * >(argp1);
  {
    try {
      result = ((std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > > const *)arg1)->get_allocator(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj((new std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > >::allocator_type(result)), SWIGTYPE_p_std__allocatorT_std__pairT_sword__SWBuf_const_std__multimapT_sword__SWBuf_sword__SWBuf_std__lessT_sword__SWBuf_t_t_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PySectionMap_erase__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > > *arg1 = 0 ;
  std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > >::key_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > >::size_type result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_sword__SWBuf_std__multimapT_sword__SWBuf_sword__SWBuf_std__lessT_sword__SWBuf_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySectionMap_erase" "', argument " "1"" of type '" "std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_sword__SWBuf,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PySectionMap_erase" "', argument " "2"" of type '" "std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > >::key_type const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "PySectionMap_erase" "', argument " "2"" of type '" "std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > >::key_type const &""'"); 
  }
  arg2 = reinterpret_cast< std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > >::key_type * >(argp2);
  {
    try {
      result = (arg1)->erase((std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > >::key_type const &)*arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PySectionMap_count(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > > *arg1 = 0 ;
  std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > >::key_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > >::size_type result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "PySectionMap_count", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_sword__SWBuf_std__multimapT_sword__SWBuf_sword__SWBuf_std__lessT_sword__SWBuf_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySectionMap_count" "', argument " "1"" of type '" "std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_sword__SWBuf,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PySectionMap_count" "', argument " "2"" of type '" "std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > >::key_type const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "PySectionMap_count" "', argument " "2"" of type '" "std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > >::key_type const &""'"); 
  }
  arg2 = reinterpret_cast< std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > >::key_type * >(argp2);
  {
    try {
      result = ((std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > > const *)arg1)->count((std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > >::key_type const &)*arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PySectionMap_erase__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > > *arg1 = 0 ;
  std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > >::iterator arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_sword__SWBuf_std__multimapT_sword__SWBuf_sword__SWBuf_std__lessT_sword__SWBuf_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySectionMap_erase" "', argument " "1"" of type '" "std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "PySectionMap_erase" "', argument " "2"" of type '" "std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "PySectionMap_erase" "', argument " "2"" of type '" "std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > >::iterator""'");
    }
  }
  {
    try {
      std_map_Sl_sword_SWBuf_Sc_std_multimap_Sl_sword_SWBuf_Sc_sword_SWBuf_Sc_std_less_Sl_sword_SWBuf_Sg__Sg__Sg__erase__SWIG_1(arg1,SWIG_STD_MOVE(arg2)); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PySectionMap_erase__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > > *arg1 = 0 ;
  std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > >::iterator arg2 ;
  std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > >::iterator arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  swig::SwigPyIterator *iter3 = 0 ;
  int res3 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_sword__SWBuf_std__multimapT_sword__SWBuf_sword__SWBuf_std__lessT_sword__SWBuf_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySectionMap_erase" "', argument " "1"" of type '" "std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "PySectionMap_erase" "', argument " "2"" of type '" "std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "PySectionMap_erase" "', argument " "2"" of type '" "std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > >::iterator""'");
    }
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], SWIG_as_voidptrptr(&iter3), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res3) || !iter3) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "PySectionMap_erase" "', argument " "3"" of type '" "std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > >::iterator > *>(iter3);
    if (iter_t) {
      arg3 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "PySectionMap_erase" "', argument " "3"" of type '" "std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > >::iterator""'");
    }
  }
  {
    try {
      std_map_Sl_sword_SWBuf_Sc_std_multimap_Sl_sword_SWBuf_Sc_sword_SWBuf_Sc_std_less_Sl_sword_SWBuf_Sg__Sg__Sg__erase__SWIG_2(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3)); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PySectionMap_erase(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "PySectionMap_erase", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_sword__SWBuf, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_PySectionMap_erase__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > >::iterator > *>(iter) != 0));
      if (_v) {
        return _wrap_PySectionMap_erase__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > >::iterator > *>(iter) != 0));
      if (_v) {
        swig::SwigPyIterator *iter = 0;
        int res = SWIG_ConvertPtr(argv[2], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
        _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > >::iterator > *>(iter) != 0));
        if (_v) {
          return _wrap_PySectionMap_erase__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PySectionMap_erase'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > >::erase(std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > >::key_type const &)\n"
    "    std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > >::erase(std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > >::iterator)\n"
    "    std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > >::erase(std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > >::iterator,std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > >::iterator)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_PySectionMap_find(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > > *arg1 = 0 ;
  std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > >::key_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > >::iterator result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "PySectionMap_find", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_sword__SWBuf_std__multimapT_sword__SWBuf_sword__SWBuf_std__lessT_sword__SWBuf_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySectionMap_find" "', argument " "1"" of type '" "std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_sword__SWBuf,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PySectionMap_find" "', argument " "2"" of type '" "std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > >::key_type const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "PySectionMap_find" "', argument " "2"" of type '" "std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > >::key_type const &""'"); 
  }
  arg2 = reinterpret_cast< std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > >::key_type * >(argp2);
  {
    try {
      result = (arg1)->find((std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > >::key_type const &)*arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PySectionMap_lower_bound(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > > *arg1 = 0 ;
  std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > >::key_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > >::iterator result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "PySectionMap_lower_bound", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_sword__SWBuf_std__multimapT_sword__SWBuf_sword__SWBuf_std__lessT_sword__SWBuf_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySectionMap_lower_bound" "', argument " "1"" of type '" "std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_sword__SWBuf,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PySectionMap_lower_bound" "', argument " "2"" of type '" "std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > >::key_type const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "PySectionMap_lower_bound" "', argument " "2"" of type '" "std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > >::key_type const &""'"); 
  }
  arg2 = reinterpret_cast< std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > >::key_type * >(argp2);
  {
    try {
      result = (arg1)->lower_bound((std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > >::key_type const &)*arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PySectionMap_upper_bound(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > > *arg1 = 0 ;
  std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > >::key_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > >::iterator result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "PySectionMap_upper_bound", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_sword__SWBuf_std__multimapT_sword__SWBuf_sword__SWBuf_std__lessT_sword__SWBuf_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySectionMap_upper_bound" "', argument " "1"" of type '" "std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_sword__SWBuf,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PySectionMap_upper_bound" "', argument " "2"" of type '" "std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > >::key_type const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "PySectionMap_upper_bound" "', argument " "2"" of type '" "std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > >::key_type const &""'"); 
  }
  arg2 = reinterpret_cast< std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > >::key_type * >(argp2);
  {
    try {
      result = (arg1)->upper_bound((std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > >::key_type const &)*arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_PySectionMap(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_sword__SWBuf_std__multimapT_sword__SWBuf_sword__SWBuf_std__lessT_sword__SWBuf_t_t_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PySectionMap" "', argument " "1"" of type '" "std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > > * >(argp1);
  {
    try {
      delete arg1; 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *PySectionMap_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__mapT_sword__SWBuf_std__multimapT_sword__SWBuf_sword__SWBuf_std__lessT_sword__SWBuf_t_t_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *PySectionMap_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_ModuleMap__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::less< sword::SWBuf > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::map< sword::SWBuf,sword::SWModule * > *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_std__lessT_sword__SWBuf_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ModuleMap" "', argument " "1"" of type '" "std::less< sword::SWBuf > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_ModuleMap" "', argument " "1"" of type '" "std::less< sword::SWBuf > const &""'"); 
  }
  arg1 = reinterpret_cast< std::less< sword::SWBuf > * >(argp1);
  {
    try {
      result = (std::map< sword::SWBuf,sword::SWModule * > *)new std::map< sword::SWBuf,sword::SWModule * >((std::less< sword::SWBuf > const &)*arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__mapT_sword__SWBuf_sword__SWModule_p_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModuleMap_iterator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::map< sword::SWBuf,sword::SWModule * > *arg1 = 0 ;
  PyObject **arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  swig::SwigPyIterator *result = 0 ;
  
  arg2 = &swig_obj[0];
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_sword__SWBuf_sword__SWModule_p_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModuleMap_iterator" "', argument " "1"" of type '" "std::map< sword::SWBuf,sword::SWModule * > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< sword::SWBuf,sword::SWModule * > * >(argp1);
  {
    try {
      result = (swig::SwigPyIterator *)std_map_Sl_sword_SWBuf_Sc_sword_SWModule_Sm__Sg__iterator(arg1,arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  if (!result) SWIG_fail;
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModuleMap___nonzero__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::map< sword::SWBuf,sword::SWModule * > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_sword__SWBuf_sword__SWModule_p_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModuleMap___nonzero__" "', argument " "1"" of type '" "std::map< sword::SWBuf,sword::SWModule * > const *""'"); 
  }
  arg1 = reinterpret_cast< std::map< sword::SWBuf,sword::SWModule * > * >(argp1);
  {
    try {
      result = (bool)std_map_Sl_sword_SWBuf_Sc_sword_SWModule_Sm__Sg____nonzero__((std::map< sword::SWBuf,sword::SWModule * > const *)arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModuleMap___bool__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::map< sword::SWBuf,sword::SWModule * > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_sword__SWBuf_sword__SWModule_p_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModuleMap___bool__" "', argument " "1"" of type '" "std::map< sword::SWBuf,sword::SWModule * > const *""'"); 
  }
  arg1 = reinterpret_cast< std::map< sword::SWBuf,sword::SWModule * > * >(argp1);
  {
    try {
      result = (bool)std_map_Sl_sword_SWBuf_Sc_sword_SWModule_Sm__Sg____bool__((std::map< sword::SWBuf,sword::SWModule * > const *)arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModuleMap___len__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::map< sword::SWBuf,sword::SWModule * > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::map< sword::SWBuf,sword::SWModule * >::size_type result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_sword__SWBuf_sword__SWModule_p_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModuleMap___len__" "', argument " "1"" of type '" "std::map< sword::SWBuf,sword::SWModule * > const *""'"); 
  }
  arg1 = reinterpret_cast< std::map< sword::SWBuf,sword::SWModule * > * >(argp1);
  {
    try {
      result = std_map_Sl_sword_SWBuf_Sc_sword_SWModule_Sm__Sg____len__((std::map< sword::SWBuf,sword::SWModule * > const *)arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModuleMap___getitem__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::map< sword::SWBuf,sword::SWModule * > *arg1 = 0 ;
  std::map< sword::SWBuf,sword::SWModule * >::key_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  std::map< sword::SWBuf,sword::SWModule * >::mapped_type *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ModuleMap___getitem__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_sword__SWBuf_sword__SWModule_p_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModuleMap___getitem__" "', argument " "1"" of type '" "std::map< sword::SWBuf,sword::SWModule * > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< sword::SWBuf,sword::SWModule * > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_sword__SWBuf,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ModuleMap___getitem__" "', argument " "2"" of type '" "std::map< sword::SWBuf,sword::SWModule * >::key_type const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "ModuleMap___getitem__" "', argument " "2"" of type '" "std::map< sword::SWBuf,sword::SWModule * >::key_type const &""'"); 
  }
  arg2 = reinterpret_cast< std::map< sword::SWBuf,sword::SWModule * >::key_type * >(argp2);
  {
    try {
      try {
        result = (std::map< sword::SWBuf,sword::SWModule * >::mapped_type *) &std_map_Sl_sword_SWBuf_Sc_sword_SWModule_Sm__Sg____getitem__(arg1,(sword::SWBuf const &)*arg2);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(*result), SWIGTYPE_p_sword__SWModule, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModuleMap___delitem__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::map< sword::SWBuf,sword::SWModule * > *arg1 = 0 ;
  std::map< sword::SWBuf,sword::SWModule * >::key_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ModuleMap___delitem__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_sword__SWBuf_sword__SWModule_p_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModuleMap___delitem__" "', argument " "1"" of type '" "std::map< sword::SWBuf,sword::SWModule * > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< sword::SWBuf,sword::SWModule * > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_sword__SWBuf,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ModuleMap___delitem__" "', argument " "2"" of type '" "std::map< sword::SWBuf,sword::SWModule * >::key_type const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "ModuleMap___delitem__" "', argument " "2"" of type '" "std::map< sword::SWBuf,sword::SWModule * >::key_type const &""'"); 
  }
  arg2 = reinterpret_cast< std::map< sword::SWBuf,sword::SWModule * >::key_type * >(argp2);
  {
    try {
      try {
        std_map_Sl_sword_SWBuf_Sc_sword_SWModule_Sm__Sg____delitem__(arg1,(sword::SWBuf const &)*arg2);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModuleMap_has_key(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::map< sword::SWBuf,sword::SWModule * > *arg1 = 0 ;
  std::map< sword::SWBuf,sword::SWModule * >::key_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ModuleMap_has_key", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_sword__SWBuf_sword__SWModule_p_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModuleMap_has_key" "', argument " "1"" of type '" "std::map< sword::SWBuf,sword::SWModule * > const *""'"); 
  }
  arg1 = reinterpret_cast< std::map< sword::SWBuf,sword::SWModule * > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_sword__SWBuf,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ModuleMap_has_key" "', argument " "2"" of type '" "std::map< sword::SWBuf,sword::SWModule * >::key_type const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "ModuleMap_has_key" "', argument " "2"" of type '" "std::map< sword::SWBuf,sword::SWModule * >::key_type const &""'"); 
  }
  arg2 = reinterpret_cast< std::map< sword::SWBuf,sword::SWModule * >::key_type * >(argp2);
  {
    try {
      result = (bool)std_map_Sl_sword_SWBuf_Sc_sword_SWModule_Sm__Sg__has_key((std::map< sword::SWBuf,sword::SWModule * > const *)arg1,(sword::SWBuf const &)*arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModuleMap_keys(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::map< sword::SWBuf,sword::SWModule * > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_sword__SWBuf_sword__SWModule_p_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModuleMap_keys" "', argument " "1"" of type '" "std::map< sword::SWBuf,sword::SWModule * > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< sword::SWBuf,sword::SWModule * > * >(argp1);
  {
    try {
      result = (PyObject *)std_map_Sl_sword_SWBuf_Sc_sword_SWModule_Sm__Sg__keys(arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = result;
  if (!resultobj) SWIG_fail;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModuleMap_values(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::map< sword::SWBuf,sword::SWModule * > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_sword__SWBuf_sword__SWModule_p_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModuleMap_values" "', argument " "1"" of type '" "std::map< sword::SWBuf,sword::SWModule * > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< sword::SWBuf,sword::SWModule * > * >(argp1);
  {
    try {
      result = (PyObject *)std_map_Sl_sword_SWBuf_Sc_sword_SWModule_Sm__Sg__values(arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = result;
  if (!resultobj) SWIG_fail;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModuleMap_items(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::map< sword::SWBuf,sword::SWModule * > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_sword__SWBuf_sword__SWModule_p_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModuleMap_items" "', argument " "1"" of type '" "std::map< sword::SWBuf,sword::SWModule * > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< sword::SWBuf,sword::SWModule * > * >(argp1);
  {
    try {
      result = (PyObject *)std_map_Sl_sword_SWBuf_Sc_sword_SWModule_Sm__Sg__items(arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = result;
  if (!resultobj) SWIG_fail;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModuleMap___contains__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::map< sword::SWBuf,sword::SWModule * > *arg1 = 0 ;
  std::map< sword::SWBuf,sword::SWModule * >::key_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ModuleMap___contains__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_sword__SWBuf_sword__SWModule_p_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModuleMap___contains__" "', argument " "1"" of type '" "std::map< sword::SWBuf,sword::SWModule * > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< sword::SWBuf,sword::SWModule * > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_sword__SWBuf,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ModuleMap___contains__" "', argument " "2"" of type '" "std::map< sword::SWBuf,sword::SWModule * >::key_type const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "ModuleMap___contains__" "', argument " "2"" of type '" "std::map< sword::SWBuf,sword::SWModule * >::key_type const &""'"); 
  }
  arg2 = reinterpret_cast< std::map< sword::SWBuf,sword::SWModule * >::key_type * >(argp2);
  {
    try {
      result = (bool)std_map_Sl_sword_SWBuf_Sc_sword_SWModule_Sm__Sg____contains__(arg1,(sword::SWBuf const &)*arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModuleMap_key_iterator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::map< sword::SWBuf,sword::SWModule * > *arg1 = 0 ;
  PyObject **arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  swig::SwigPyIterator *result = 0 ;
  
  arg2 = &swig_obj[0];
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_sword__SWBuf_sword__SWModule_p_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModuleMap_key_iterator" "', argument " "1"" of type '" "std::map< sword::SWBuf,sword::SWModule * > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< sword::SWBuf,sword::SWModule * > * >(argp1);
  {
    try {
      result = (swig::SwigPyIterator *)std_map_Sl_sword_SWBuf_Sc_sword_SWModule_Sm__Sg__key_iterator(arg1,arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  if (!result) SWIG_fail;
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModuleMap_value_iterator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::map< sword::SWBuf,sword::SWModule * > *arg1 = 0 ;
  PyObject **arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  swig::SwigPyIterator *result = 0 ;
  
  arg2 = &swig_obj[0];
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_sword__SWBuf_sword__SWModule_p_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModuleMap_value_iterator" "', argument " "1"" of type '" "std::map< sword::SWBuf,sword::SWModule * > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< sword::SWBuf,sword::SWModule * > * >(argp1);
  {
    try {
      result = (swig::SwigPyIterator *)std_map_Sl_sword_SWBuf_Sc_sword_SWModule_Sm__Sg__value_iterator(arg1,arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  if (!result) SWIG_fail;
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModuleMap___setitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::map< sword::SWBuf,sword::SWModule * > *arg1 = 0 ;
  std::map< sword::SWBuf,sword::SWModule * >::key_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_sword__SWBuf_sword__SWModule_p_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModuleMap___setitem__" "', argument " "1"" of type '" "std::map< sword::SWBuf,sword::SWModule * > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< sword::SWBuf,sword::SWModule * > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_sword__SWBuf,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ModuleMap___setitem__" "', argument " "2"" of type '" "std::map< sword::SWBuf,sword::SWModule * >::key_type const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "ModuleMap___setitem__" "', argument " "2"" of type '" "std::map< sword::SWBuf,sword::SWModule * >::key_type const &""'"); 
  }
  arg2 = reinterpret_cast< std::map< sword::SWBuf,sword::SWModule * >::key_type * >(argp2);
  {
    try {
      std_map_Sl_sword_SWBuf_Sc_sword_SWModule_Sm__Sg____setitem____SWIG_0(arg1,(sword::SWBuf const &)*arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModuleMap___setitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::map< sword::SWBuf,sword::SWModule * > *arg1 = 0 ;
  std::map< sword::SWBuf,sword::SWModule * >::key_type *arg2 = 0 ;
  std::map< sword::SWBuf,sword::SWModule * >::mapped_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  std::map< sword::SWBuf,sword::SWModule * >::mapped_type temp3 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_sword__SWBuf_sword__SWModule_p_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModuleMap___setitem__" "', argument " "1"" of type '" "std::map< sword::SWBuf,sword::SWModule * > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< sword::SWBuf,sword::SWModule * > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_sword__SWBuf,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ModuleMap___setitem__" "', argument " "2"" of type '" "std::map< sword::SWBuf,sword::SWModule * >::key_type const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "ModuleMap___setitem__" "', argument " "2"" of type '" "std::map< sword::SWBuf,sword::SWModule * >::key_type const &""'"); 
  }
  arg2 = reinterpret_cast< std::map< sword::SWBuf,sword::SWModule * >::key_type * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_sword__SWModule, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ModuleMap___setitem__" "', argument " "3"" of type '" "std::map< sword::SWBuf,sword::SWModule * >::mapped_type""'"); 
  }
  temp3 = reinterpret_cast< std::map< sword::SWBuf,sword::SWModule * >::mapped_type >(argp3);
  arg3 = reinterpret_cast< std::map< sword::SWBuf,sword::SWModule * >::mapped_type * >(&temp3);
  {
    try {
      try {
        std_map_Sl_sword_SWBuf_Sc_sword_SWModule_Sm__Sg____setitem____SWIG_1(arg1,(sword::SWBuf const &)*arg2,(sword::SWModule *const &)*arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModuleMap___setitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "ModuleMap___setitem__", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::map< sword::SWBuf,sword::SWModule *,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWModule * > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_sword__SWBuf, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_ModuleMap___setitem____SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::map< sword::SWBuf,sword::SWModule *,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWModule * > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_sword__SWBuf, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_sword__SWModule, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_ModuleMap___setitem____SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ModuleMap___setitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::map< sword::SWBuf,sword::SWModule * >::__setitem__(std::map< sword::SWBuf,sword::SWModule * >::key_type const &)\n"
    "    std::map< sword::SWBuf,sword::SWModule * >::__setitem__(std::map< sword::SWBuf,sword::SWModule * >::key_type const &,std::map< sword::SWBuf,sword::SWModule * >::mapped_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ModuleMap_asdict(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::map< sword::SWBuf,sword::SWModule * > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_sword__SWBuf_sword__SWModule_p_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModuleMap_asdict" "', argument " "1"" of type '" "std::map< sword::SWBuf,sword::SWModule * > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< sword::SWBuf,sword::SWModule * > * >(argp1);
  {
    try {
      result = (PyObject *)std_map_Sl_sword_SWBuf_Sc_sword_SWModule_Sm__Sg__asdict(arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = result;
  if (!resultobj) SWIG_fail;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ModuleMap__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  std::map< sword::SWBuf,sword::SWModule * > *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (std::map< sword::SWBuf,sword::SWModule * > *)new std::map< sword::SWBuf,sword::SWModule * >(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__mapT_sword__SWBuf_sword__SWModule_p_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ModuleMap__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::map< sword::SWBuf,sword::SWModule * > *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  std::map< sword::SWBuf,sword::SWModule * > *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    std::map< sword::SWBuf,sword::SWModule *,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWModule * > > > *ptr = (std::map< sword::SWBuf,sword::SWModule *,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWModule * > > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ModuleMap" "', argument " "1"" of type '" "std::map< sword::SWBuf,sword::SWModule * > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_ModuleMap" "', argument " "1"" of type '" "std::map< sword::SWBuf,sword::SWModule * > const &""'"); 
    }
    arg1 = ptr;
  }
  {
    try {
      result = (std::map< sword::SWBuf,sword::SWModule * > *)new std::map< sword::SWBuf,sword::SWModule * >((std::map< sword::SWBuf,sword::SWModule * > const &)*arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__mapT_sword__SWBuf_sword__SWModule_p_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ModuleMap(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_ModuleMap", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_ModuleMap__SWIG_1(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_std__lessT_sword__SWBuf_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ModuleMap__SWIG_0(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::map< sword::SWBuf,sword::SWModule *,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWModule * > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ModuleMap__SWIG_2(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_ModuleMap'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::map< sword::SWBuf,sword::SWModule * >::map(std::less< sword::SWBuf > const &)\n"
    "    std::map< sword::SWBuf,sword::SWModule * >::map()\n"
    "    std::map< sword::SWBuf,sword::SWModule * >::map(std::map< sword::SWBuf,sword::SWModule * > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ModuleMap_empty(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::map< sword::SWBuf,sword::SWModule * > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_sword__SWBuf_sword__SWModule_p_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModuleMap_empty" "', argument " "1"" of type '" "std::map< sword::SWBuf,sword::SWModule * > const *""'"); 
  }
  arg1 = reinterpret_cast< std::map< sword::SWBuf,sword::SWModule * > * >(argp1);
  {
    try {
      result = (bool)((std::map< sword::SWBuf,sword::SWModule * > const *)arg1)->empty(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModuleMap_size(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::map< sword::SWBuf,sword::SWModule * > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::map< sword::SWBuf,sword::SWModule * >::size_type result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_sword__SWBuf_sword__SWModule_p_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModuleMap_size" "', argument " "1"" of type '" "std::map< sword::SWBuf,sword::SWModule * > const *""'"); 
  }
  arg1 = reinterpret_cast< std::map< sword::SWBuf,sword::SWModule * > * >(argp1);
  {
    try {
      result = ((std::map< sword::SWBuf,sword::SWModule * > const *)arg1)->size(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModuleMap_swap(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::map< sword::SWBuf,sword::SWModule * > *arg1 = 0 ;
  std::map< sword::SWBuf,sword::SWModule * > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ModuleMap_swap", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_sword__SWBuf_sword__SWModule_p_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModuleMap_swap" "', argument " "1"" of type '" "std::map< sword::SWBuf,sword::SWModule * > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< sword::SWBuf,sword::SWModule * > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__mapT_sword__SWBuf_sword__SWModule_p_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ModuleMap_swap" "', argument " "2"" of type '" "std::map< sword::SWBuf,sword::SWModule * > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "ModuleMap_swap" "', argument " "2"" of type '" "std::map< sword::SWBuf,sword::SWModule * > &""'"); 
  }
  arg2 = reinterpret_cast< std::map< sword::SWBuf,sword::SWModule * > * >(argp2);
  {
    try {
      (arg1)->swap(*arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModuleMap_begin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::map< sword::SWBuf,sword::SWModule * > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::map< sword::SWBuf,sword::SWModule * >::iterator result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_sword__SWBuf_sword__SWModule_p_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModuleMap_begin" "', argument " "1"" of type '" "std::map< sword::SWBuf,sword::SWModule * > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< sword::SWBuf,sword::SWModule * > * >(argp1);
  {
    try {
      result = (arg1)->begin(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::map< sword::SWBuf,sword::SWModule * >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModuleMap_end(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::map< sword::SWBuf,sword::SWModule * > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::map< sword::SWBuf,sword::SWModule * >::iterator result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_sword__SWBuf_sword__SWModule_p_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModuleMap_end" "', argument " "1"" of type '" "std::map< sword::SWBuf,sword::SWModule * > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< sword::SWBuf,sword::SWModule * > * >(argp1);
  {
    try {
      result = (arg1)->end(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::map< sword::SWBuf,sword::SWModule * >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModuleMap_rbegin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::map< sword::SWBuf,sword::SWModule * > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::map< sword::SWBuf,sword::SWModule * >::reverse_iterator result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_sword__SWBuf_sword__SWModule_p_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModuleMap_rbegin" "', argument " "1"" of type '" "std::map< sword::SWBuf,sword::SWModule * > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< sword::SWBuf,sword::SWModule * > * >(argp1);
  {
    try {
      result = (arg1)->rbegin(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::map< sword::SWBuf,sword::SWModule * >::reverse_iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModuleMap_rend(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::map< sword::SWBuf,sword::SWModule * > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::map< sword::SWBuf,sword::SWModule * >::reverse_iterator result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_sword__SWBuf_sword__SWModule_p_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModuleMap_rend" "', argument " "1"" of type '" "std::map< sword::SWBuf,sword::SWModule * > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< sword::SWBuf,sword::SWModule * > * >(argp1);
  {
    try {
      result = (arg1)->rend(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::map< sword::SWBuf,sword::SWModule * >::reverse_iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModuleMap_clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::map< sword::SWBuf,sword::SWModule * > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_sword__SWBuf_sword__SWModule_p_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModuleMap_clear" "', argument " "1"" of type '" "std::map< sword::SWBuf,sword::SWModule * > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< sword::SWBuf,sword::SWModule * > * >(argp1);
  {
    try {
      (arg1)->clear(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModuleMap_get_allocator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::map< sword::SWBuf,sword::SWModule * > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< std::allocator< std::pair< sword::SWBuf const,sword::SWModule * > > > result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_sword__SWBuf_sword__SWModule_p_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModuleMap_get_allocator" "', argument " "1"" of type '" "std::map< sword::SWBuf,sword::SWModule * > const *""'"); 
  }
  arg1 = reinterpret_cast< std::map< sword::SWBuf,sword::SWModule * > * >(argp1);
  {
    try {
      result = ((std::map< sword::SWBuf,sword::SWModule * > const *)arg1)->get_allocator(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj((new std::map< sword::SWBuf,sword::SWModule * >::allocator_type(result)), SWIGTYPE_p_std__allocatorT_std__pairT_sword__SWBuf_const_sword__SWModule_p_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModuleMap_erase__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::map< sword::SWBuf,sword::SWModule * > *arg1 = 0 ;
  std::map< sword::SWBuf,sword::SWModule * >::key_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  std::map< sword::SWBuf,sword::SWModule * >::size_type result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_sword__SWBuf_sword__SWModule_p_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModuleMap_erase" "', argument " "1"" of type '" "std::map< sword::SWBuf,sword::SWModule * > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< sword::SWBuf,sword::SWModule * > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_sword__SWBuf,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ModuleMap_erase" "', argument " "2"" of type '" "std::map< sword::SWBuf,sword::SWModule * >::key_type const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "ModuleMap_erase" "', argument " "2"" of type '" "std::map< sword::SWBuf,sword::SWModule * >::key_type const &""'"); 
  }
  arg2 = reinterpret_cast< std::map< sword::SWBuf,sword::SWModule * >::key_type * >(argp2);
  {
    try {
      result = (arg1)->erase((std::map< sword::SWBuf,sword::SWModule * >::key_type const &)*arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModuleMap_count(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::map< sword::SWBuf,sword::SWModule * > *arg1 = 0 ;
  std::map< sword::SWBuf,sword::SWModule * >::key_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  std::map< sword::SWBuf,sword::SWModule * >::size_type result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ModuleMap_count", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_sword__SWBuf_sword__SWModule_p_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModuleMap_count" "', argument " "1"" of type '" "std::map< sword::SWBuf,sword::SWModule * > const *""'"); 
  }
  arg1 = reinterpret_cast< std::map< sword::SWBuf,sword::SWModule * > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_sword__SWBuf,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ModuleMap_count" "', argument " "2"" of type '" "std::map< sword::SWBuf,sword::SWModule * >::key_type const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "ModuleMap_count" "', argument " "2"" of type '" "std::map< sword::SWBuf,sword::SWModule * >::key_type const &""'"); 
  }
  arg2 = reinterpret_cast< std::map< sword::SWBuf,sword::SWModule * >::key_type * >(argp2);
  {
    try {
      result = ((std::map< sword::SWBuf,sword::SWModule * > const *)arg1)->count((std::map< sword::SWBuf,sword::SWModule * >::key_type const &)*arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModuleMap_erase__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::map< sword::SWBuf,sword::SWModule * > *arg1 = 0 ;
  std::map< sword::SWBuf,sword::SWModule * >::iterator arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_sword__SWBuf_sword__SWModule_p_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModuleMap_erase" "', argument " "1"" of type '" "std::map< sword::SWBuf,sword::SWModule * > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< sword::SWBuf,sword::SWModule * > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "ModuleMap_erase" "', argument " "2"" of type '" "std::map< sword::SWBuf,sword::SWModule * >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::map< sword::SWBuf,sword::SWModule * >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::map< sword::SWBuf,sword::SWModule * >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "ModuleMap_erase" "', argument " "2"" of type '" "std::map< sword::SWBuf,sword::SWModule * >::iterator""'");
    }
  }
  {
    try {
      std_map_Sl_sword_SWBuf_Sc_sword_SWModule_Sm__Sg__erase__SWIG_1(arg1,SWIG_STD_MOVE(arg2)); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModuleMap_erase__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::map< sword::SWBuf,sword::SWModule * > *arg1 = 0 ;
  std::map< sword::SWBuf,sword::SWModule * >::iterator arg2 ;
  std::map< sword::SWBuf,sword::SWModule * >::iterator arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  swig::SwigPyIterator *iter3 = 0 ;
  int res3 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_sword__SWBuf_sword__SWModule_p_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModuleMap_erase" "', argument " "1"" of type '" "std::map< sword::SWBuf,sword::SWModule * > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< sword::SWBuf,sword::SWModule * > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "ModuleMap_erase" "', argument " "2"" of type '" "std::map< sword::SWBuf,sword::SWModule * >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::map< sword::SWBuf,sword::SWModule * >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::map< sword::SWBuf,sword::SWModule * >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "ModuleMap_erase" "', argument " "2"" of type '" "std::map< sword::SWBuf,sword::SWModule * >::iterator""'");
    }
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], SWIG_as_voidptrptr(&iter3), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res3) || !iter3) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "ModuleMap_erase" "', argument " "3"" of type '" "std::map< sword::SWBuf,sword::SWModule * >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::map< sword::SWBuf,sword::SWModule * >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::map< sword::SWBuf,sword::SWModule * >::iterator > *>(iter3);
    if (iter_t) {
      arg3 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "ModuleMap_erase" "', argument " "3"" of type '" "std::map< sword::SWBuf,sword::SWModule * >::iterator""'");
    }
  }
  {
    try {
      std_map_Sl_sword_SWBuf_Sc_sword_SWModule_Sm__Sg__erase__SWIG_2(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3)); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModuleMap_erase(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "ModuleMap_erase", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::map< sword::SWBuf,sword::SWModule *,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWModule * > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_sword__SWBuf, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_ModuleMap_erase__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::map< sword::SWBuf,sword::SWModule *,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWModule * > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::map< sword::SWBuf,sword::SWModule * >::iterator > *>(iter) != 0));
      if (_v) {
        return _wrap_ModuleMap_erase__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::map< sword::SWBuf,sword::SWModule *,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWModule * > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::map< sword::SWBuf,sword::SWModule * >::iterator > *>(iter) != 0));
      if (_v) {
        swig::SwigPyIterator *iter = 0;
        int res = SWIG_ConvertPtr(argv[2], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
        _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::map< sword::SWBuf,sword::SWModule * >::iterator > *>(iter) != 0));
        if (_v) {
          return _wrap_ModuleMap_erase__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ModuleMap_erase'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::map< sword::SWBuf,sword::SWModule * >::erase(std::map< sword::SWBuf,sword::SWModule * >::key_type const &)\n"
    "    std::map< sword::SWBuf,sword::SWModule * >::erase(std::map< sword::SWBuf,sword::SWModule * >::iterator)\n"
    "    std::map< sword::SWBuf,sword::SWModule * >::erase(std::map< sword::SWBuf,sword::SWModule * >::iterator,std::map< sword::SWBuf,sword::SWModule * >::iterator)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ModuleMap_find(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::map< sword::SWBuf,sword::SWModule * > *arg1 = 0 ;
  std::map< sword::SWBuf,sword::SWModule * >::key_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  std::map< sword::SWBuf,sword::SWModule * >::iterator result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ModuleMap_find", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_sword__SWBuf_sword__SWModule_p_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModuleMap_find" "', argument " "1"" of type '" "std::map< sword::SWBuf,sword::SWModule * > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< sword::SWBuf,sword::SWModule * > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_sword__SWBuf,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ModuleMap_find" "', argument " "2"" of type '" "std::map< sword::SWBuf,sword::SWModule * >::key_type const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "ModuleMap_find" "', argument " "2"" of type '" "std::map< sword::SWBuf,sword::SWModule * >::key_type const &""'"); 
  }
  arg2 = reinterpret_cast< std::map< sword::SWBuf,sword::SWModule * >::key_type * >(argp2);
  {
    try {
      result = (arg1)->find((std::map< sword::SWBuf,sword::SWModule * >::key_type const &)*arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::map< sword::SWBuf,sword::SWModule * >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModuleMap_lower_bound(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::map< sword::SWBuf,sword::SWModule * > *arg1 = 0 ;
  std::map< sword::SWBuf,sword::SWModule * >::key_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  std::map< sword::SWBuf,sword::SWModule * >::iterator result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ModuleMap_lower_bound", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_sword__SWBuf_sword__SWModule_p_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModuleMap_lower_bound" "', argument " "1"" of type '" "std::map< sword::SWBuf,sword::SWModule * > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< sword::SWBuf,sword::SWModule * > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_sword__SWBuf,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ModuleMap_lower_bound" "', argument " "2"" of type '" "std::map< sword::SWBuf,sword::SWModule * >::key_type const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "ModuleMap_lower_bound" "', argument " "2"" of type '" "std::map< sword::SWBuf,sword::SWModule * >::key_type const &""'"); 
  }
  arg2 = reinterpret_cast< std::map< sword::SWBuf,sword::SWModule * >::key_type * >(argp2);
  {
    try {
      result = (arg1)->lower_bound((std::map< sword::SWBuf,sword::SWModule * >::key_type const &)*arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::map< sword::SWBuf,sword::SWModule * >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModuleMap_upper_bound(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::map< sword::SWBuf,sword::SWModule * > *arg1 = 0 ;
  std::map< sword::SWBuf,sword::SWModule * >::key_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  std::map< sword::SWBuf,sword::SWModule * >::iterator result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ModuleMap_upper_bound", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_sword__SWBuf_sword__SWModule_p_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModuleMap_upper_bound" "', argument " "1"" of type '" "std::map< sword::SWBuf,sword::SWModule * > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< sword::SWBuf,sword::SWModule * > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_sword__SWBuf,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ModuleMap_upper_bound" "', argument " "2"" of type '" "std::map< sword::SWBuf,sword::SWModule * >::key_type const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "ModuleMap_upper_bound" "', argument " "2"" of type '" "std::map< sword::SWBuf,sword::SWModule * >::key_type const &""'"); 
  }
  arg2 = reinterpret_cast< std::map< sword::SWBuf,sword::SWModule * >::key_type * >(argp2);
  {
    try {
      result = (arg1)->upper_bound((std::map< sword::SWBuf,sword::SWModule * >::key_type const &)*arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::map< sword::SWBuf,sword::SWModule * >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ModuleMap(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::map< sword::SWBuf,sword::SWModule * > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_sword__SWBuf_sword__SWModule_p_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ModuleMap" "', argument " "1"" of type '" "std::map< sword::SWBuf,sword::SWModule * > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< sword::SWBuf,sword::SWModule * > * >(argp1);
  {
    try {
      delete arg1; 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ModuleMap_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__mapT_sword__SWBuf_sword__SWModule_p_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *ModuleMap_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_StringVector_iterator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< sword::SWBuf > *arg1 = 0 ;
  PyObject **arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  swig::SwigPyIterator *result = 0 ;
  
  arg2 = &swig_obj[0];
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_sword__SWBuf_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringVector_iterator" "', argument " "1"" of type '" "std::vector< sword::SWBuf > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< sword::SWBuf > * >(argp1);
  {
    try {
      result = (swig::SwigPyIterator *)std_vector_Sl_sword_SWBuf_Sg__iterator(arg1,arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  if (!result) SWIG_fail;
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringVector___nonzero__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< sword::SWBuf > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_sword__SWBuf_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringVector___nonzero__" "', argument " "1"" of type '" "std::vector< sword::SWBuf > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< sword::SWBuf > * >(argp1);
  {
    try {
      result = (bool)std_vector_Sl_sword_SWBuf_Sg____nonzero__((std::vector< sword::SWBuf > const *)arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringVector___bool__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< sword::SWBuf > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_sword__SWBuf_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringVector___bool__" "', argument " "1"" of type '" "std::vector< sword::SWBuf > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< sword::SWBuf > * >(argp1);
  {
    try {
      result = (bool)std_vector_Sl_sword_SWBuf_Sg____bool__((std::vector< sword::SWBuf > const *)arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringVector___len__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< sword::SWBuf > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< sword::SWBuf >::size_type result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_sword__SWBuf_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringVector___len__" "', argument " "1"" of type '" "std::vector< sword::SWBuf > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< sword::SWBuf > * >(argp1);
  {
    try {
      result = std_vector_Sl_sword_SWBuf_Sg____len__((std::vector< sword::SWBuf > const *)arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringVector___getslice__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< sword::SWBuf > *arg1 = 0 ;
  std::vector< sword::SWBuf >::difference_type arg2 ;
  std::vector< sword::SWBuf >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  std::vector< sword::SWBuf,std::allocator< sword::SWBuf > > *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "StringVector___getslice__", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_sword__SWBuf_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringVector___getslice__" "', argument " "1"" of type '" "std::vector< sword::SWBuf > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< sword::SWBuf > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StringVector___getslice__" "', argument " "2"" of type '" "std::vector< sword::SWBuf >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< sword::SWBuf >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "StringVector___getslice__" "', argument " "3"" of type '" "std::vector< sword::SWBuf >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< sword::SWBuf >::difference_type >(val3);
  {
    try {
      try {
        result = (std::vector< sword::SWBuf,std::allocator< sword::SWBuf > > *)std_vector_Sl_sword_SWBuf_Sg____getslice__(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      } 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_sword__SWBuf_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringVector___setslice____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< sword::SWBuf > *arg1 = 0 ;
  std::vector< sword::SWBuf >::difference_type arg2 ;
  std::vector< sword::SWBuf >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_sword__SWBuf_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringVector___setslice__" "', argument " "1"" of type '" "std::vector< sword::SWBuf > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< sword::SWBuf > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StringVector___setslice__" "', argument " "2"" of type '" "std::vector< sword::SWBuf >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< sword::SWBuf >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "StringVector___setslice__" "', argument " "3"" of type '" "std::vector< sword::SWBuf >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< sword::SWBuf >::difference_type >(val3);
  {
    try {
      try {
        std_vector_Sl_sword_SWBuf_Sg____setslice____SWIG_0(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      } 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringVector___setslice____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< sword::SWBuf > *arg1 = 0 ;
  std::vector< sword::SWBuf >::difference_type arg2 ;
  std::vector< sword::SWBuf >::difference_type arg3 ;
  std::vector< sword::SWBuf,std::allocator< sword::SWBuf > > *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_sword__SWBuf_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringVector___setslice__" "', argument " "1"" of type '" "std::vector< sword::SWBuf > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< sword::SWBuf > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StringVector___setslice__" "', argument " "2"" of type '" "std::vector< sword::SWBuf >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< sword::SWBuf >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "StringVector___setslice__" "', argument " "3"" of type '" "std::vector< sword::SWBuf >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< sword::SWBuf >::difference_type >(val3);
  {
    std::vector< sword::SWBuf,std::allocator< sword::SWBuf > > *ptr = (std::vector< sword::SWBuf,std::allocator< sword::SWBuf > > *)0;
    res4 = swig::asptr(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "StringVector___setslice__" "', argument " "4"" of type '" "std::vector< sword::SWBuf,std::allocator< sword::SWBuf > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "StringVector___setslice__" "', argument " "4"" of type '" "std::vector< sword::SWBuf,std::allocator< sword::SWBuf > > const &""'"); 
    }
    arg4 = ptr;
  }
  {
    try {
      try {
        std_vector_Sl_sword_SWBuf_Sg____setslice____SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),(std::vector< sword::SWBuf,std::allocator< sword::SWBuf > > const &)*arg4);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      } 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res4)) delete arg4;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res4)) delete arg4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringVector___setslice__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "StringVector___setslice__", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< sword::SWBuf,std::allocator< sword::SWBuf > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_StringVector___setslice____SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< sword::SWBuf,std::allocator< sword::SWBuf > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = swig::asptr(argv[3], (std::vector< sword::SWBuf,std::allocator< sword::SWBuf > >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_StringVector___setslice____SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'StringVector___setslice__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< sword::SWBuf >::__setslice__(std::vector< sword::SWBuf >::difference_type,std::vector< sword::SWBuf >::difference_type)\n"
    "    std::vector< sword::SWBuf >::__setslice__(std::vector< sword::SWBuf >::difference_type,std::vector< sword::SWBuf >::difference_type,std::vector< sword::SWBuf,std::allocator< sword::SWBuf > > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_StringVector___delslice__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< sword::SWBuf > *arg1 = 0 ;
  std::vector< sword::SWBuf >::difference_type arg2 ;
  std::vector< sword::SWBuf >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "StringVector___delslice__", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_sword__SWBuf_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringVector___delslice__" "', argument " "1"" of type '" "std::vector< sword::SWBuf > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< sword::SWBuf > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StringVector___delslice__" "', argument " "2"" of type '" "std::vector< sword::SWBuf >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< sword::SWBuf >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "StringVector___delslice__" "', argument " "3"" of type '" "std::vector< sword::SWBuf >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< sword::SWBuf >::difference_type >(val3);
  {
    try {
      try {
        std_vector_Sl_sword_SWBuf_Sg____delslice__(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      } 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringVector___delitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< sword::SWBuf > *arg1 = 0 ;
  std::vector< sword::SWBuf >::difference_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_sword__SWBuf_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringVector___delitem__" "', argument " "1"" of type '" "std::vector< sword::SWBuf > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< sword::SWBuf > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StringVector___delitem__" "', argument " "2"" of type '" "std::vector< sword::SWBuf >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< sword::SWBuf >::difference_type >(val2);
  {
    try {
      try {
        std_vector_Sl_sword_SWBuf_Sg____delitem____SWIG_0(arg1,SWIG_STD_MOVE(arg2));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      } 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringVector___getitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< sword::SWBuf > *arg1 = 0 ;
  SWIGPY_SLICEOBJECT *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< sword::SWBuf,std::allocator< sword::SWBuf > > *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_sword__SWBuf_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringVector___getitem__" "', argument " "1"" of type '" "std::vector< sword::SWBuf > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< sword::SWBuf > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "StringVector___getitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    try {
      try {
        result = (std::vector< sword::SWBuf,std::allocator< sword::SWBuf > > *)std_vector_Sl_sword_SWBuf_Sg____getitem____SWIG_0(arg1,arg2);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      } 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_sword__SWBuf_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringVector___setitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< sword::SWBuf > *arg1 = 0 ;
  SWIGPY_SLICEOBJECT *arg2 = 0 ;
  std::vector< sword::SWBuf,std::allocator< sword::SWBuf > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_sword__SWBuf_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringVector___setitem__" "', argument " "1"" of type '" "std::vector< sword::SWBuf > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< sword::SWBuf > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "StringVector___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    std::vector< sword::SWBuf,std::allocator< sword::SWBuf > > *ptr = (std::vector< sword::SWBuf,std::allocator< sword::SWBuf > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "StringVector___setitem__" "', argument " "3"" of type '" "std::vector< sword::SWBuf,std::allocator< sword::SWBuf > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "StringVector___setitem__" "', argument " "3"" of type '" "std::vector< sword::SWBuf,std::allocator< sword::SWBuf > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      try {
        std_vector_Sl_sword_SWBuf_Sg____setitem____SWIG_0(arg1,arg2,(std::vector< sword::SWBuf,std::allocator< sword::SWBuf > > const &)*arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      } 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringVector___setitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< sword::SWBuf > *arg1 = 0 ;
  SWIGPY_SLICEOBJECT *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_sword__SWBuf_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringVector___setitem__" "', argument " "1"" of type '" "std::vector< sword::SWBuf > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< sword::SWBuf > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "StringVector___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    try {
      try {
        std_vector_Sl_sword_SWBuf_Sg____setitem____SWIG_1(arg1,arg2);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      } 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringVector___delitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< sword::SWBuf > *arg1 = 0 ;
  SWIGPY_SLICEOBJECT *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_sword__SWBuf_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringVector___delitem__" "', argument " "1"" of type '" "std::vector< sword::SWBuf > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< sword::SWBuf > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "StringVector___delitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    try {
      try {
        std_vector_Sl_sword_SWBuf_Sg____delitem____SWIG_1(arg1,arg2);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      } 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringVector___delitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "StringVector___delitem__", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< sword::SWBuf,std::allocator< sword::SWBuf > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        return _wrap_StringVector___delitem____SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< sword::SWBuf,std::allocator< sword::SWBuf > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_StringVector___delitem____SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'StringVector___delitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< sword::SWBuf >::__delitem__(std::vector< sword::SWBuf >::difference_type)\n"
    "    std::vector< sword::SWBuf >::__delitem__(SWIGPY_SLICEOBJECT *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_StringVector___getitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< sword::SWBuf > *arg1 = 0 ;
  std::vector< sword::SWBuf >::difference_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  std::vector< sword::SWBuf >::value_type *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_sword__SWBuf_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringVector___getitem__" "', argument " "1"" of type '" "std::vector< sword::SWBuf > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< sword::SWBuf > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StringVector___getitem__" "', argument " "2"" of type '" "std::vector< sword::SWBuf >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< sword::SWBuf >::difference_type >(val2);
  {
    try {
      try {
        result = (std::vector< sword::SWBuf >::value_type *) &std_vector_Sl_sword_SWBuf_Sg____getitem____SWIG_1((std::vector< sword::SWBuf > const *)arg1,SWIG_STD_MOVE(arg2));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__SWBuf, 0 |  0 );
  if (!swig::container_owner<swig::traits<std::vector< sword::SWBuf >::value_type>::category>::back_reference(resultobj, swig_obj[0]) && PyErr_Occurred()) {
    SWIG_fail;
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringVector___getitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "StringVector___getitem__", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< sword::SWBuf,std::allocator< sword::SWBuf > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        return _wrap_StringVector___getitem____SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< sword::SWBuf,std::allocator< sword::SWBuf > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_StringVector___getitem____SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'StringVector___getitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< sword::SWBuf >::__getitem__(SWIGPY_SLICEOBJECT *)\n"
    "    std::vector< sword::SWBuf >::__getitem__(std::vector< sword::SWBuf >::difference_type) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_StringVector___setitem____SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< sword::SWBuf > *arg1 = 0 ;
  std::vector< sword::SWBuf >::difference_type arg2 ;
  std::vector< sword::SWBuf >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_sword__SWBuf_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringVector___setitem__" "', argument " "1"" of type '" "std::vector< sword::SWBuf > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< sword::SWBuf > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StringVector___setitem__" "', argument " "2"" of type '" "std::vector< sword::SWBuf >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< sword::SWBuf >::difference_type >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_sword__SWBuf,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "StringVector___setitem__" "', argument " "3"" of type '" "std::vector< sword::SWBuf >::value_type const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "StringVector___setitem__" "', argument " "3"" of type '" "std::vector< sword::SWBuf >::value_type const &""'"); 
  }
  arg3 = reinterpret_cast< std::vector< sword::SWBuf >::value_type * >(argp3);
  {
    try {
      try {
        std_vector_Sl_sword_SWBuf_Sg____setitem____SWIG_2(arg1,SWIG_STD_MOVE(arg2),(sword::SWBuf const &)*arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringVector___setitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "StringVector___setitem__", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< sword::SWBuf,std::allocator< sword::SWBuf > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        return _wrap_StringVector___setitem____SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< sword::SWBuf,std::allocator< sword::SWBuf > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< sword::SWBuf,std::allocator< sword::SWBuf > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_StringVector___setitem____SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< sword::SWBuf,std::allocator< sword::SWBuf > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_sword__SWBuf, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_StringVector___setitem____SWIG_2(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'StringVector___setitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< sword::SWBuf >::__setitem__(SWIGPY_SLICEOBJECT *,std::vector< sword::SWBuf,std::allocator< sword::SWBuf > > const &)\n"
    "    std::vector< sword::SWBuf >::__setitem__(SWIGPY_SLICEOBJECT *)\n"
    "    std::vector< sword::SWBuf >::__setitem__(std::vector< sword::SWBuf >::difference_type,std::vector< sword::SWBuf >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_StringVector_pop(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< sword::SWBuf > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< sword::SWBuf >::value_type result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_sword__SWBuf_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringVector_pop" "', argument " "1"" of type '" "std::vector< sword::SWBuf > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< sword::SWBuf > * >(argp1);
  {
    try {
      try {
        result = std_vector_Sl_sword_SWBuf_Sg__pop(arg1);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj((new std::vector< sword::SWBuf >::value_type(result)), SWIGTYPE_p_sword__SWBuf, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringVector_append(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< sword::SWBuf > *arg1 = 0 ;
  std::vector< sword::SWBuf >::value_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "StringVector_append", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_sword__SWBuf_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringVector_append" "', argument " "1"" of type '" "std::vector< sword::SWBuf > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< sword::SWBuf > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_sword__SWBuf,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StringVector_append" "', argument " "2"" of type '" "std::vector< sword::SWBuf >::value_type const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "StringVector_append" "', argument " "2"" of type '" "std::vector< sword::SWBuf >::value_type const &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< sword::SWBuf >::value_type * >(argp2);
  {
    try {
      std_vector_Sl_sword_SWBuf_Sg__append(arg1,(sword::SWBuf const &)*arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_StringVector__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  std::vector< sword::SWBuf > *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (std::vector< sword::SWBuf > *)new std::vector< sword::SWBuf >(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_sword__SWBuf_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_StringVector__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< sword::SWBuf > *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  std::vector< sword::SWBuf > *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    std::vector< sword::SWBuf,std::allocator< sword::SWBuf > > *ptr = (std::vector< sword::SWBuf,std::allocator< sword::SWBuf > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_StringVector" "', argument " "1"" of type '" "std::vector< sword::SWBuf > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_StringVector" "', argument " "1"" of type '" "std::vector< sword::SWBuf > const &""'"); 
    }
    arg1 = ptr;
  }
  {
    try {
      result = (std::vector< sword::SWBuf > *)new std::vector< sword::SWBuf >((std::vector< sword::SWBuf > const &)*arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_sword__SWBuf_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringVector_empty(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< sword::SWBuf > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_sword__SWBuf_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringVector_empty" "', argument " "1"" of type '" "std::vector< sword::SWBuf > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< sword::SWBuf > * >(argp1);
  {
    try {
      result = (bool)((std::vector< sword::SWBuf > const *)arg1)->empty(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringVector_size(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< sword::SWBuf > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< sword::SWBuf >::size_type result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_sword__SWBuf_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringVector_size" "', argument " "1"" of type '" "std::vector< sword::SWBuf > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< sword::SWBuf > * >(argp1);
  {
    try {
      result = ((std::vector< sword::SWBuf > const *)arg1)->size(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringVector_swap(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< sword::SWBuf > *arg1 = 0 ;
  std::vector< sword::SWBuf > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "StringVector_swap", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_sword__SWBuf_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringVector_swap" "', argument " "1"" of type '" "std::vector< sword::SWBuf > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< sword::SWBuf > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_sword__SWBuf_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StringVector_swap" "', argument " "2"" of type '" "std::vector< sword::SWBuf > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "StringVector_swap" "', argument " "2"" of type '" "std::vector< sword::SWBuf > &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< sword::SWBuf > * >(argp2);
  {
    try {
      (arg1)->swap(*arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringVector_begin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< sword::SWBuf > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< sword::SWBuf >::iterator result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_sword__SWBuf_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringVector_begin" "', argument " "1"" of type '" "std::vector< sword::SWBuf > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< sword::SWBuf > * >(argp1);
  {
    try {
      result = (arg1)->begin(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< sword::SWBuf >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringVector_end(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< sword::SWBuf > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< sword::SWBuf >::iterator result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_sword__SWBuf_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringVector_end" "', argument " "1"" of type '" "std::vector< sword::SWBuf > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< sword::SWBuf > * >(argp1);
  {
    try {
      result = (arg1)->end(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< sword::SWBuf >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringVector_rbegin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< sword::SWBuf > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< sword::SWBuf >::reverse_iterator result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_sword__SWBuf_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringVector_rbegin" "', argument " "1"" of type '" "std::vector< sword::SWBuf > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< sword::SWBuf > * >(argp1);
  {
    try {
      result = (arg1)->rbegin(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< sword::SWBuf >::reverse_iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringVector_rend(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< sword::SWBuf > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< sword::SWBuf >::reverse_iterator result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_sword__SWBuf_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringVector_rend" "', argument " "1"" of type '" "std::vector< sword::SWBuf > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< sword::SWBuf > * >(argp1);
  {
    try {
      result = (arg1)->rend(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< sword::SWBuf >::reverse_iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringVector_clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< sword::SWBuf > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_sword__SWBuf_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringVector_clear" "', argument " "1"" of type '" "std::vector< sword::SWBuf > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< sword::SWBuf > * >(argp1);
  {
    try {
      (arg1)->clear(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringVector_get_allocator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< sword::SWBuf > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< std::allocator< sword::SWBuf > > result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_sword__SWBuf_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringVector_get_allocator" "', argument " "1"" of type '" "std::vector< sword::SWBuf > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< sword::SWBuf > * >(argp1);
  {
    try {
      result = ((std::vector< sword::SWBuf > const *)arg1)->get_allocator(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj((new std::vector< sword::SWBuf >::allocator_type(result)), SWIGTYPE_p_std__allocatorT_sword__SWBuf_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_StringVector__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< sword::SWBuf >::size_type arg1 ;
  size_t val1 ;
  int ecode1 = 0 ;
  std::vector< sword::SWBuf > *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_StringVector" "', argument " "1"" of type '" "std::vector< sword::SWBuf >::size_type""'");
  } 
  arg1 = static_cast< std::vector< sword::SWBuf >::size_type >(val1);
  {
    try {
      result = (std::vector< sword::SWBuf > *)new std::vector< sword::SWBuf >(SWIG_STD_MOVE(arg1)); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_sword__SWBuf_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringVector_pop_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< sword::SWBuf > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_sword__SWBuf_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringVector_pop_back" "', argument " "1"" of type '" "std::vector< sword::SWBuf > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< sword::SWBuf > * >(argp1);
  {
    try {
      (arg1)->pop_back(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringVector_resize__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< sword::SWBuf > *arg1 = 0 ;
  std::vector< sword::SWBuf >::size_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_sword__SWBuf_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringVector_resize" "', argument " "1"" of type '" "std::vector< sword::SWBuf > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< sword::SWBuf > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StringVector_resize" "', argument " "2"" of type '" "std::vector< sword::SWBuf >::size_type""'");
  } 
  arg2 = static_cast< std::vector< sword::SWBuf >::size_type >(val2);
  {
    try {
      (arg1)->resize(SWIG_STD_MOVE(arg2)); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringVector_erase__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< sword::SWBuf > *arg1 = 0 ;
  std::vector< sword::SWBuf >::iterator arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  std::vector< sword::SWBuf >::iterator result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_sword__SWBuf_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringVector_erase" "', argument " "1"" of type '" "std::vector< sword::SWBuf > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< sword::SWBuf > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "StringVector_erase" "', argument " "2"" of type '" "std::vector< sword::SWBuf >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< sword::SWBuf >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< sword::SWBuf >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "StringVector_erase" "', argument " "2"" of type '" "std::vector< sword::SWBuf >::iterator""'");
    }
  }
  {
    try {
      result = std_vector_Sl_sword_SWBuf_Sg__erase__SWIG_0(arg1,SWIG_STD_MOVE(arg2)); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< sword::SWBuf >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringVector_erase__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< sword::SWBuf > *arg1 = 0 ;
  std::vector< sword::SWBuf >::iterator arg2 ;
  std::vector< sword::SWBuf >::iterator arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  swig::SwigPyIterator *iter3 = 0 ;
  int res3 ;
  std::vector< sword::SWBuf >::iterator result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_sword__SWBuf_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringVector_erase" "', argument " "1"" of type '" "std::vector< sword::SWBuf > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< sword::SWBuf > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "StringVector_erase" "', argument " "2"" of type '" "std::vector< sword::SWBuf >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< sword::SWBuf >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< sword::SWBuf >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "StringVector_erase" "', argument " "2"" of type '" "std::vector< sword::SWBuf >::iterator""'");
    }
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], SWIG_as_voidptrptr(&iter3), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res3) || !iter3) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "StringVector_erase" "', argument " "3"" of type '" "std::vector< sword::SWBuf >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< sword::SWBuf >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< sword::SWBuf >::iterator > *>(iter3);
    if (iter_t) {
      arg3 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "StringVector_erase" "', argument " "3"" of type '" "std::vector< sword::SWBuf >::iterator""'");
    }
  }
  {
    try {
      result = std_vector_Sl_sword_SWBuf_Sg__erase__SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3)); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< sword::SWBuf >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringVector_erase(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "StringVector_erase", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< sword::SWBuf,std::allocator< sword::SWBuf > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< sword::SWBuf >::iterator > *>(iter) != 0));
      if (_v) {
        return _wrap_StringVector_erase__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< sword::SWBuf,std::allocator< sword::SWBuf > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< sword::SWBuf >::iterator > *>(iter) != 0));
      if (_v) {
        swig::SwigPyIterator *iter = 0;
        int res = SWIG_ConvertPtr(argv[2], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
        _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< sword::SWBuf >::iterator > *>(iter) != 0));
        if (_v) {
          return _wrap_StringVector_erase__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'StringVector_erase'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< sword::SWBuf >::erase(std::vector< sword::SWBuf >::iterator)\n"
    "    std::vector< sword::SWBuf >::erase(std::vector< sword::SWBuf >::iterator,std::vector< sword::SWBuf >::iterator)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_new_StringVector__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< sword::SWBuf >::size_type arg1 ;
  std::vector< sword::SWBuf >::value_type *arg2 = 0 ;
  size_t val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  std::vector< sword::SWBuf > *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_StringVector" "', argument " "1"" of type '" "std::vector< sword::SWBuf >::size_type""'");
  } 
  arg1 = static_cast< std::vector< sword::SWBuf >::size_type >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_sword__SWBuf,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_StringVector" "', argument " "2"" of type '" "std::vector< sword::SWBuf >::value_type const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_StringVector" "', argument " "2"" of type '" "std::vector< sword::SWBuf >::value_type const &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< sword::SWBuf >::value_type * >(argp2);
  {
    try {
      result = (std::vector< sword::SWBuf > *)new std::vector< sword::SWBuf >(SWIG_STD_MOVE(arg1),(std::vector< sword::SWBuf >::value_type const &)*arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_sword__SWBuf_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_StringVector(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_StringVector", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_StringVector__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_StringVector__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< sword::SWBuf,std::allocator< sword::SWBuf > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_StringVector__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_sword__SWBuf, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_StringVector__SWIG_3(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_StringVector'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< sword::SWBuf >::vector()\n"
    "    std::vector< sword::SWBuf >::vector(std::vector< sword::SWBuf > const &)\n"
    "    std::vector< sword::SWBuf >::vector(std::vector< sword::SWBuf >::size_type)\n"
    "    std::vector< sword::SWBuf >::vector(std::vector< sword::SWBuf >::size_type,std::vector< sword::SWBuf >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_StringVector_push_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< sword::SWBuf > *arg1 = 0 ;
  std::vector< sword::SWBuf >::value_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "StringVector_push_back", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_sword__SWBuf_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringVector_push_back" "', argument " "1"" of type '" "std::vector< sword::SWBuf > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< sword::SWBuf > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_sword__SWBuf,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StringVector_push_back" "', argument " "2"" of type '" "std::vector< sword::SWBuf >::value_type const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "StringVector_push_back" "', argument " "2"" of type '" "std::vector< sword::SWBuf >::value_type const &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< sword::SWBuf >::value_type * >(argp2);
  {
    try {
      (arg1)->push_back((std::vector< sword::SWBuf >::value_type const &)*arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringVector_front(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< sword::SWBuf > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< sword::SWBuf >::value_type *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_sword__SWBuf_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringVector_front" "', argument " "1"" of type '" "std::vector< sword::SWBuf > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< sword::SWBuf > * >(argp1);
  {
    try {
      result = (std::vector< sword::SWBuf >::value_type *) &((std::vector< sword::SWBuf > const *)arg1)->front(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__SWBuf, 0 |  0 );
  if (!swig::container_owner<swig::traits<std::vector< sword::SWBuf >::value_type>::category>::back_reference(resultobj, swig_obj[0]) && PyErr_Occurred()) {
    SWIG_fail;
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringVector_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< sword::SWBuf > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< sword::SWBuf >::value_type *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_sword__SWBuf_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringVector_back" "', argument " "1"" of type '" "std::vector< sword::SWBuf > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< sword::SWBuf > * >(argp1);
  {
    try {
      result = (std::vector< sword::SWBuf >::value_type *) &((std::vector< sword::SWBuf > const *)arg1)->back(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__SWBuf, 0 |  0 );
  if (!swig::container_owner<swig::traits<std::vector< sword::SWBuf >::value_type>::category>::back_reference(resultobj, swig_obj[0]) && PyErr_Occurred()) {
    SWIG_fail;
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringVector_assign(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< sword::SWBuf > *arg1 = 0 ;
  std::vector< sword::SWBuf >::size_type arg2 ;
  std::vector< sword::SWBuf >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "StringVector_assign", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_sword__SWBuf_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringVector_assign" "', argument " "1"" of type '" "std::vector< sword::SWBuf > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< sword::SWBuf > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StringVector_assign" "', argument " "2"" of type '" "std::vector< sword::SWBuf >::size_type""'");
  } 
  arg2 = static_cast< std::vector< sword::SWBuf >::size_type >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_sword__SWBuf,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "StringVector_assign" "', argument " "3"" of type '" "std::vector< sword::SWBuf >::value_type const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "StringVector_assign" "', argument " "3"" of type '" "std::vector< sword::SWBuf >::value_type const &""'"); 
  }
  arg3 = reinterpret_cast< std::vector< sword::SWBuf >::value_type * >(argp3);
  {
    try {
      (arg1)->assign(SWIG_STD_MOVE(arg2),(std::vector< sword::SWBuf >::value_type const &)*arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringVector_resize__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< sword::SWBuf > *arg1 = 0 ;
  std::vector< sword::SWBuf >::size_type arg2 ;
  std::vector< sword::SWBuf >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_sword__SWBuf_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringVector_resize" "', argument " "1"" of type '" "std::vector< sword::SWBuf > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< sword::SWBuf > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StringVector_resize" "', argument " "2"" of type '" "std::vector< sword::SWBuf >::size_type""'");
  } 
  arg2 = static_cast< std::vector< sword::SWBuf >::size_type >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_sword__SWBuf,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "StringVector_resize" "', argument " "3"" of type '" "std::vector< sword::SWBuf >::value_type const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "StringVector_resize" "', argument " "3"" of type '" "std::vector< sword::SWBuf >::value_type const &""'"); 
  }
  arg3 = reinterpret_cast< std::vector< sword::SWBuf >::value_type * >(argp3);
  {
    try {
      (arg1)->resize(SWIG_STD_MOVE(arg2),(std::vector< sword::SWBuf >::value_type const &)*arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringVector_resize(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "StringVector_resize", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< sword::SWBuf,std::allocator< sword::SWBuf > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_StringVector_resize__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< sword::SWBuf,std::allocator< sword::SWBuf > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_sword__SWBuf, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_StringVector_resize__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'StringVector_resize'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< sword::SWBuf >::resize(std::vector< sword::SWBuf >::size_type)\n"
    "    std::vector< sword::SWBuf >::resize(std::vector< sword::SWBuf >::size_type,std::vector< sword::SWBuf >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_StringVector_insert__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< sword::SWBuf > *arg1 = 0 ;
  std::vector< sword::SWBuf >::iterator arg2 ;
  std::vector< sword::SWBuf >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  std::vector< sword::SWBuf >::iterator result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_sword__SWBuf_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringVector_insert" "', argument " "1"" of type '" "std::vector< sword::SWBuf > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< sword::SWBuf > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "StringVector_insert" "', argument " "2"" of type '" "std::vector< sword::SWBuf >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< sword::SWBuf >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< sword::SWBuf >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "StringVector_insert" "', argument " "2"" of type '" "std::vector< sword::SWBuf >::iterator""'");
    }
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_sword__SWBuf,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "StringVector_insert" "', argument " "3"" of type '" "std::vector< sword::SWBuf >::value_type const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "StringVector_insert" "', argument " "3"" of type '" "std::vector< sword::SWBuf >::value_type const &""'"); 
  }
  arg3 = reinterpret_cast< std::vector< sword::SWBuf >::value_type * >(argp3);
  {
    try {
      result = std_vector_Sl_sword_SWBuf_Sg__insert__SWIG_0(arg1,SWIG_STD_MOVE(arg2),(sword::SWBuf const &)*arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< sword::SWBuf >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringVector_insert__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< sword::SWBuf > *arg1 = 0 ;
  std::vector< sword::SWBuf >::iterator arg2 ;
  std::vector< sword::SWBuf >::size_type arg3 ;
  std::vector< sword::SWBuf >::value_type *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  size_t val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_sword__SWBuf_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringVector_insert" "', argument " "1"" of type '" "std::vector< sword::SWBuf > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< sword::SWBuf > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "StringVector_insert" "', argument " "2"" of type '" "std::vector< sword::SWBuf >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< sword::SWBuf >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< sword::SWBuf >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "StringVector_insert" "', argument " "2"" of type '" "std::vector< sword::SWBuf >::iterator""'");
    }
  }
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "StringVector_insert" "', argument " "3"" of type '" "std::vector< sword::SWBuf >::size_type""'");
  } 
  arg3 = static_cast< std::vector< sword::SWBuf >::size_type >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_sword__SWBuf,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "StringVector_insert" "', argument " "4"" of type '" "std::vector< sword::SWBuf >::value_type const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "StringVector_insert" "', argument " "4"" of type '" "std::vector< sword::SWBuf >::value_type const &""'"); 
  }
  arg4 = reinterpret_cast< std::vector< sword::SWBuf >::value_type * >(argp4);
  {
    try {
      std_vector_Sl_sword_SWBuf_Sg__insert__SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),(sword::SWBuf const &)*arg4); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringVector_insert(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "StringVector_insert", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< sword::SWBuf,std::allocator< sword::SWBuf > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< sword::SWBuf >::iterator > *>(iter) != 0));
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_sword__SWBuf, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_StringVector_insert__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< sword::SWBuf,std::allocator< sword::SWBuf > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< sword::SWBuf >::iterator > *>(iter) != 0));
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_sword__SWBuf, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_StringVector_insert__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'StringVector_insert'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< sword::SWBuf >::insert(std::vector< sword::SWBuf >::iterator,std::vector< sword::SWBuf >::value_type const &)\n"
    "    std::vector< sword::SWBuf >::insert(std::vector< sword::SWBuf >::iterator,std::vector< sword::SWBuf >::size_type,std::vector< sword::SWBuf >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_StringVector_reserve(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< sword::SWBuf > *arg1 = 0 ;
  std::vector< sword::SWBuf >::size_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "StringVector_reserve", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_sword__SWBuf_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringVector_reserve" "', argument " "1"" of type '" "std::vector< sword::SWBuf > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< sword::SWBuf > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StringVector_reserve" "', argument " "2"" of type '" "std::vector< sword::SWBuf >::size_type""'");
  } 
  arg2 = static_cast< std::vector< sword::SWBuf >::size_type >(val2);
  {
    try {
      (arg1)->reserve(SWIG_STD_MOVE(arg2)); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringVector_capacity(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< sword::SWBuf > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< sword::SWBuf >::size_type result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_sword__SWBuf_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringVector_capacity" "', argument " "1"" of type '" "std::vector< sword::SWBuf > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< sword::SWBuf > * >(argp1);
  {
    try {
      result = ((std::vector< sword::SWBuf > const *)arg1)->capacity(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_StringVector(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< sword::SWBuf > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_sword__SWBuf_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_StringVector" "', argument " "1"" of type '" "std::vector< sword::SWBuf > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< sword::SWBuf > * >(argp1);
  {
    try {
      delete arg1; 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *StringVector_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__vectorT_sword__SWBuf_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *StringVector_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_StringList_iterator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::list< sword::SWBuf > *arg1 = 0 ;
  PyObject **arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  swig::SwigPyIterator *result = 0 ;
  
  arg2 = &swig_obj[0];
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__listT_sword__SWBuf_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringList_iterator" "', argument " "1"" of type '" "std::list< sword::SWBuf > *""'"); 
  }
  arg1 = reinterpret_cast< std::list< sword::SWBuf > * >(argp1);
  {
    try {
      result = (swig::SwigPyIterator *)std_list_Sl_sword_SWBuf_Sg__iterator(arg1,arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  if (!result) SWIG_fail;
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringList___nonzero__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::list< sword::SWBuf > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__listT_sword__SWBuf_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringList___nonzero__" "', argument " "1"" of type '" "std::list< sword::SWBuf > const *""'"); 
  }
  arg1 = reinterpret_cast< std::list< sword::SWBuf > * >(argp1);
  {
    try {
      result = (bool)std_list_Sl_sword_SWBuf_Sg____nonzero__((std::list< sword::SWBuf > const *)arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringList___bool__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::list< sword::SWBuf > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__listT_sword__SWBuf_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringList___bool__" "', argument " "1"" of type '" "std::list< sword::SWBuf > const *""'"); 
  }
  arg1 = reinterpret_cast< std::list< sword::SWBuf > * >(argp1);
  {
    try {
      result = (bool)std_list_Sl_sword_SWBuf_Sg____bool__((std::list< sword::SWBuf > const *)arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringList___len__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::list< sword::SWBuf > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::list< sword::SWBuf >::size_type result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__listT_sword__SWBuf_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringList___len__" "', argument " "1"" of type '" "std::list< sword::SWBuf > const *""'"); 
  }
  arg1 = reinterpret_cast< std::list< sword::SWBuf > * >(argp1);
  {
    try {
      result = std_list_Sl_sword_SWBuf_Sg____len__((std::list< sword::SWBuf > const *)arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringList___getslice__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::list< sword::SWBuf > *arg1 = 0 ;
  std::list< sword::SWBuf >::difference_type arg2 ;
  std::list< sword::SWBuf >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  std::list< sword::SWBuf,std::allocator< sword::SWBuf > > *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "StringList___getslice__", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__listT_sword__SWBuf_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringList___getslice__" "', argument " "1"" of type '" "std::list< sword::SWBuf > *""'"); 
  }
  arg1 = reinterpret_cast< std::list< sword::SWBuf > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StringList___getslice__" "', argument " "2"" of type '" "std::list< sword::SWBuf >::difference_type""'");
  } 
  arg2 = static_cast< std::list< sword::SWBuf >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "StringList___getslice__" "', argument " "3"" of type '" "std::list< sword::SWBuf >::difference_type""'");
  } 
  arg3 = static_cast< std::list< sword::SWBuf >::difference_type >(val3);
  {
    try {
      try {
        result = (std::list< sword::SWBuf,std::allocator< sword::SWBuf > > *)std_list_Sl_sword_SWBuf_Sg____getslice__(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      } 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__listT_sword__SWBuf_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringList___setslice____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::list< sword::SWBuf > *arg1 = 0 ;
  std::list< sword::SWBuf >::difference_type arg2 ;
  std::list< sword::SWBuf >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__listT_sword__SWBuf_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringList___setslice__" "', argument " "1"" of type '" "std::list< sword::SWBuf > *""'"); 
  }
  arg1 = reinterpret_cast< std::list< sword::SWBuf > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StringList___setslice__" "', argument " "2"" of type '" "std::list< sword::SWBuf >::difference_type""'");
  } 
  arg2 = static_cast< std::list< sword::SWBuf >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "StringList___setslice__" "', argument " "3"" of type '" "std::list< sword::SWBuf >::difference_type""'");
  } 
  arg3 = static_cast< std::list< sword::SWBuf >::difference_type >(val3);
  {
    try {
      try {
        std_list_Sl_sword_SWBuf_Sg____setslice____SWIG_0(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      } 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringList___setslice____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::list< sword::SWBuf > *arg1 = 0 ;
  std::list< sword::SWBuf >::difference_type arg2 ;
  std::list< sword::SWBuf >::difference_type arg3 ;
  std::list< sword::SWBuf,std::allocator< sword::SWBuf > > *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__listT_sword__SWBuf_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringList___setslice__" "', argument " "1"" of type '" "std::list< sword::SWBuf > *""'"); 
  }
  arg1 = reinterpret_cast< std::list< sword::SWBuf > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StringList___setslice__" "', argument " "2"" of type '" "std::list< sword::SWBuf >::difference_type""'");
  } 
  arg2 = static_cast< std::list< sword::SWBuf >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "StringList___setslice__" "', argument " "3"" of type '" "std::list< sword::SWBuf >::difference_type""'");
  } 
  arg3 = static_cast< std::list< sword::SWBuf >::difference_type >(val3);
  {
    std::list< sword::SWBuf,std::allocator< sword::SWBuf > > *ptr = (std::list< sword::SWBuf,std::allocator< sword::SWBuf > > *)0;
    res4 = swig::asptr(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "StringList___setslice__" "', argument " "4"" of type '" "std::list< sword::SWBuf,std::allocator< sword::SWBuf > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "StringList___setslice__" "', argument " "4"" of type '" "std::list< sword::SWBuf,std::allocator< sword::SWBuf > > const &""'"); 
    }
    arg4 = ptr;
  }
  {
    try {
      try {
        std_list_Sl_sword_SWBuf_Sg____setslice____SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),(std::list< sword::SWBuf,std::allocator< sword::SWBuf > > const &)*arg4);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      } 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res4)) delete arg4;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res4)) delete arg4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringList___setslice__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "StringList___setslice__", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::list< sword::SWBuf,std::allocator< sword::SWBuf > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_StringList___setslice____SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::list< sword::SWBuf,std::allocator< sword::SWBuf > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = swig::asptr(argv[3], (std::list< sword::SWBuf,std::allocator< sword::SWBuf > >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_StringList___setslice____SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'StringList___setslice__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::list< sword::SWBuf >::__setslice__(std::list< sword::SWBuf >::difference_type,std::list< sword::SWBuf >::difference_type)\n"
    "    std::list< sword::SWBuf >::__setslice__(std::list< sword::SWBuf >::difference_type,std::list< sword::SWBuf >::difference_type,std::list< sword::SWBuf,std::allocator< sword::SWBuf > > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_StringList___delslice__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::list< sword::SWBuf > *arg1 = 0 ;
  std::list< sword::SWBuf >::difference_type arg2 ;
  std::list< sword::SWBuf >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "StringList___delslice__", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__listT_sword__SWBuf_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringList___delslice__" "', argument " "1"" of type '" "std::list< sword::SWBuf > *""'"); 
  }
  arg1 = reinterpret_cast< std::list< sword::SWBuf > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StringList___delslice__" "', argument " "2"" of type '" "std::list< sword::SWBuf >::difference_type""'");
  } 
  arg2 = static_cast< std::list< sword::SWBuf >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "StringList___delslice__" "', argument " "3"" of type '" "std::list< sword::SWBuf >::difference_type""'");
  } 
  arg3 = static_cast< std::list< sword::SWBuf >::difference_type >(val3);
  {
    try {
      try {
        std_list_Sl_sword_SWBuf_Sg____delslice__(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      } 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringList___delitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::list< sword::SWBuf > *arg1 = 0 ;
  std::list< sword::SWBuf >::difference_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__listT_sword__SWBuf_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringList___delitem__" "', argument " "1"" of type '" "std::list< sword::SWBuf > *""'"); 
  }
  arg1 = reinterpret_cast< std::list< sword::SWBuf > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StringList___delitem__" "', argument " "2"" of type '" "std::list< sword::SWBuf >::difference_type""'");
  } 
  arg2 = static_cast< std::list< sword::SWBuf >::difference_type >(val2);
  {
    try {
      try {
        std_list_Sl_sword_SWBuf_Sg____delitem____SWIG_0(arg1,SWIG_STD_MOVE(arg2));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      } 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringList___getitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::list< sword::SWBuf > *arg1 = 0 ;
  SWIGPY_SLICEOBJECT *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::list< sword::SWBuf,std::allocator< sword::SWBuf > > *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__listT_sword__SWBuf_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringList___getitem__" "', argument " "1"" of type '" "std::list< sword::SWBuf > *""'"); 
  }
  arg1 = reinterpret_cast< std::list< sword::SWBuf > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "StringList___getitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    try {
      try {
        result = (std::list< sword::SWBuf,std::allocator< sword::SWBuf > > *)std_list_Sl_sword_SWBuf_Sg____getitem____SWIG_0(arg1,arg2);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      } 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__listT_sword__SWBuf_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringList___setitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::list< sword::SWBuf > *arg1 = 0 ;
  SWIGPY_SLICEOBJECT *arg2 = 0 ;
  std::list< sword::SWBuf,std::allocator< sword::SWBuf > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__listT_sword__SWBuf_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringList___setitem__" "', argument " "1"" of type '" "std::list< sword::SWBuf > *""'"); 
  }
  arg1 = reinterpret_cast< std::list< sword::SWBuf > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "StringList___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    std::list< sword::SWBuf,std::allocator< sword::SWBuf > > *ptr = (std::list< sword::SWBuf,std::allocator< sword::SWBuf > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "StringList___setitem__" "', argument " "3"" of type '" "std::list< sword::SWBuf,std::allocator< sword::SWBuf > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "StringList___setitem__" "', argument " "3"" of type '" "std::list< sword::SWBuf,std::allocator< sword::SWBuf > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      try {
        std_list_Sl_sword_SWBuf_Sg____setitem____SWIG_0(arg1,arg2,(std::list< sword::SWBuf,std::allocator< sword::SWBuf > > const &)*arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      } 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringList___setitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::list< sword::SWBuf > *arg1 = 0 ;
  SWIGPY_SLICEOBJECT *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__listT_sword__SWBuf_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringList___setitem__" "', argument " "1"" of type '" "std::list< sword::SWBuf > *""'"); 
  }
  arg1 = reinterpret_cast< std::list< sword::SWBuf > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "StringList___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    try {
      try {
        std_list_Sl_sword_SWBuf_Sg____setitem____SWIG_1(arg1,arg2);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      } 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringList___delitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::list< sword::SWBuf > *arg1 = 0 ;
  SWIGPY_SLICEOBJECT *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__listT_sword__SWBuf_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringList___delitem__" "', argument " "1"" of type '" "std::list< sword::SWBuf > *""'"); 
  }
  arg1 = reinterpret_cast< std::list< sword::SWBuf > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "StringList___delitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    try {
      try {
        std_list_Sl_sword_SWBuf_Sg____delitem____SWIG_1(arg1,arg2);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      } 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringList___delitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "StringList___delitem__", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::list< sword::SWBuf,std::allocator< sword::SWBuf > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        return _wrap_StringList___delitem____SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::list< sword::SWBuf,std::allocator< sword::SWBuf > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_StringList___delitem____SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'StringList___delitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::list< sword::SWBuf >::__delitem__(std::list< sword::SWBuf >::difference_type)\n"
    "    std::list< sword::SWBuf >::__delitem__(SWIGPY_SLICEOBJECT *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_StringList___getitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::list< sword::SWBuf > *arg1 = 0 ;
  std::list< sword::SWBuf >::difference_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  std::list< sword::SWBuf >::value_type *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__listT_sword__SWBuf_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringList___getitem__" "', argument " "1"" of type '" "std::list< sword::SWBuf > const *""'"); 
  }
  arg1 = reinterpret_cast< std::list< sword::SWBuf > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StringList___getitem__" "', argument " "2"" of type '" "std::list< sword::SWBuf >::difference_type""'");
  } 
  arg2 = static_cast< std::list< sword::SWBuf >::difference_type >(val2);
  {
    try {
      try {
        result = (std::list< sword::SWBuf >::value_type *) &std_list_Sl_sword_SWBuf_Sg____getitem____SWIG_1((std::list< sword::SWBuf > const *)arg1,SWIG_STD_MOVE(arg2));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__SWBuf, 0 |  0 );
  if (!swig::container_owner<swig::traits<std::list< sword::SWBuf >::value_type>::category>::back_reference(resultobj, swig_obj[0]) && PyErr_Occurred()) {
    SWIG_fail;
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringList___getitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "StringList___getitem__", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::list< sword::SWBuf,std::allocator< sword::SWBuf > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        return _wrap_StringList___getitem____SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::list< sword::SWBuf,std::allocator< sword::SWBuf > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_StringList___getitem____SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'StringList___getitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::list< sword::SWBuf >::__getitem__(SWIGPY_SLICEOBJECT *)\n"
    "    std::list< sword::SWBuf >::__getitem__(std::list< sword::SWBuf >::difference_type) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_StringList___setitem____SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::list< sword::SWBuf > *arg1 = 0 ;
  std::list< sword::SWBuf >::difference_type arg2 ;
  std::list< sword::SWBuf >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__listT_sword__SWBuf_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringList___setitem__" "', argument " "1"" of type '" "std::list< sword::SWBuf > *""'"); 
  }
  arg1 = reinterpret_cast< std::list< sword::SWBuf > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StringList___setitem__" "', argument " "2"" of type '" "std::list< sword::SWBuf >::difference_type""'");
  } 
  arg2 = static_cast< std::list< sword::SWBuf >::difference_type >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_sword__SWBuf,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "StringList___setitem__" "', argument " "3"" of type '" "std::list< sword::SWBuf >::value_type const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "StringList___setitem__" "', argument " "3"" of type '" "std::list< sword::SWBuf >::value_type const &""'"); 
  }
  arg3 = reinterpret_cast< std::list< sword::SWBuf >::value_type * >(argp3);
  {
    try {
      try {
        std_list_Sl_sword_SWBuf_Sg____setitem____SWIG_2(arg1,SWIG_STD_MOVE(arg2),(sword::SWBuf const &)*arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringList___setitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "StringList___setitem__", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::list< sword::SWBuf,std::allocator< sword::SWBuf > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        return _wrap_StringList___setitem____SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::list< sword::SWBuf,std::allocator< sword::SWBuf > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        int res = swig::asptr(argv[2], (std::list< sword::SWBuf,std::allocator< sword::SWBuf > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_StringList___setitem____SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::list< sword::SWBuf,std::allocator< sword::SWBuf > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_sword__SWBuf, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_StringList___setitem____SWIG_2(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'StringList___setitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::list< sword::SWBuf >::__setitem__(SWIGPY_SLICEOBJECT *,std::list< sword::SWBuf,std::allocator< sword::SWBuf > > const &)\n"
    "    std::list< sword::SWBuf >::__setitem__(SWIGPY_SLICEOBJECT *)\n"
    "    std::list< sword::SWBuf >::__setitem__(std::list< sword::SWBuf >::difference_type,std::list< sword::SWBuf >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_StringList_pop(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::list< sword::SWBuf > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::list< sword::SWBuf >::value_type result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__listT_sword__SWBuf_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringList_pop" "', argument " "1"" of type '" "std::list< sword::SWBuf > *""'"); 
  }
  arg1 = reinterpret_cast< std::list< sword::SWBuf > * >(argp1);
  {
    try {
      try {
        result = std_list_Sl_sword_SWBuf_Sg__pop(arg1);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj((new std::list< sword::SWBuf >::value_type(result)), SWIGTYPE_p_sword__SWBuf, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringList_append(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::list< sword::SWBuf > *arg1 = 0 ;
  std::list< sword::SWBuf >::value_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "StringList_append", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__listT_sword__SWBuf_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringList_append" "', argument " "1"" of type '" "std::list< sword::SWBuf > *""'"); 
  }
  arg1 = reinterpret_cast< std::list< sword::SWBuf > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_sword__SWBuf,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StringList_append" "', argument " "2"" of type '" "std::list< sword::SWBuf >::value_type const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "StringList_append" "', argument " "2"" of type '" "std::list< sword::SWBuf >::value_type const &""'"); 
  }
  arg2 = reinterpret_cast< std::list< sword::SWBuf >::value_type * >(argp2);
  {
    try {
      std_list_Sl_sword_SWBuf_Sg__append(arg1,(sword::SWBuf const &)*arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_StringList__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  std::list< sword::SWBuf > *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (std::list< sword::SWBuf > *)new std::list< sword::SWBuf >(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__listT_sword__SWBuf_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_StringList__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::list< sword::SWBuf > *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  std::list< sword::SWBuf > *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    std::list< sword::SWBuf,std::allocator< sword::SWBuf > > *ptr = (std::list< sword::SWBuf,std::allocator< sword::SWBuf > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_StringList" "', argument " "1"" of type '" "std::list< sword::SWBuf > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_StringList" "', argument " "1"" of type '" "std::list< sword::SWBuf > const &""'"); 
    }
    arg1 = ptr;
  }
  {
    try {
      result = (std::list< sword::SWBuf > *)new std::list< sword::SWBuf >((std::list< sword::SWBuf > const &)*arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__listT_sword__SWBuf_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringList_empty(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::list< sword::SWBuf > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__listT_sword__SWBuf_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringList_empty" "', argument " "1"" of type '" "std::list< sword::SWBuf > const *""'"); 
  }
  arg1 = reinterpret_cast< std::list< sword::SWBuf > * >(argp1);
  {
    try {
      result = (bool)((std::list< sword::SWBuf > const *)arg1)->empty(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringList_size(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::list< sword::SWBuf > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::list< sword::SWBuf >::size_type result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__listT_sword__SWBuf_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringList_size" "', argument " "1"" of type '" "std::list< sword::SWBuf > const *""'"); 
  }
  arg1 = reinterpret_cast< std::list< sword::SWBuf > * >(argp1);
  {
    try {
      result = ((std::list< sword::SWBuf > const *)arg1)->size(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringList_swap(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::list< sword::SWBuf > *arg1 = 0 ;
  std::list< sword::SWBuf > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "StringList_swap", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__listT_sword__SWBuf_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringList_swap" "', argument " "1"" of type '" "std::list< sword::SWBuf > *""'"); 
  }
  arg1 = reinterpret_cast< std::list< sword::SWBuf > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__listT_sword__SWBuf_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StringList_swap" "', argument " "2"" of type '" "std::list< sword::SWBuf > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "StringList_swap" "', argument " "2"" of type '" "std::list< sword::SWBuf > &""'"); 
  }
  arg2 = reinterpret_cast< std::list< sword::SWBuf > * >(argp2);
  {
    try {
      (arg1)->swap(*arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringList_begin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::list< sword::SWBuf > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::list< sword::SWBuf >::iterator result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__listT_sword__SWBuf_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringList_begin" "', argument " "1"" of type '" "std::list< sword::SWBuf > *""'"); 
  }
  arg1 = reinterpret_cast< std::list< sword::SWBuf > * >(argp1);
  {
    try {
      result = (arg1)->begin(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::list< sword::SWBuf >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringList_end(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::list< sword::SWBuf > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::list< sword::SWBuf >::iterator result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__listT_sword__SWBuf_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringList_end" "', argument " "1"" of type '" "std::list< sword::SWBuf > *""'"); 
  }
  arg1 = reinterpret_cast< std::list< sword::SWBuf > * >(argp1);
  {
    try {
      result = (arg1)->end(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::list< sword::SWBuf >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringList_rbegin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::list< sword::SWBuf > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::list< sword::SWBuf >::reverse_iterator result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__listT_sword__SWBuf_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringList_rbegin" "', argument " "1"" of type '" "std::list< sword::SWBuf > *""'"); 
  }
  arg1 = reinterpret_cast< std::list< sword::SWBuf > * >(argp1);
  {
    try {
      result = (arg1)->rbegin(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::list< sword::SWBuf >::reverse_iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringList_rend(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::list< sword::SWBuf > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::list< sword::SWBuf >::reverse_iterator result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__listT_sword__SWBuf_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringList_rend" "', argument " "1"" of type '" "std::list< sword::SWBuf > *""'"); 
  }
  arg1 = reinterpret_cast< std::list< sword::SWBuf > * >(argp1);
  {
    try {
      result = (arg1)->rend(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::list< sword::SWBuf >::reverse_iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringList_clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::list< sword::SWBuf > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__listT_sword__SWBuf_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringList_clear" "', argument " "1"" of type '" "std::list< sword::SWBuf > *""'"); 
  }
  arg1 = reinterpret_cast< std::list< sword::SWBuf > * >(argp1);
  {
    try {
      (arg1)->clear(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringList_get_allocator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::list< sword::SWBuf > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< std::allocator< sword::SWBuf > > result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__listT_sword__SWBuf_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringList_get_allocator" "', argument " "1"" of type '" "std::list< sword::SWBuf > const *""'"); 
  }
  arg1 = reinterpret_cast< std::list< sword::SWBuf > * >(argp1);
  {
    try {
      result = ((std::list< sword::SWBuf > const *)arg1)->get_allocator(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj((new std::list< sword::SWBuf >::allocator_type(result)), SWIGTYPE_p_std__allocatorT_sword__SWBuf_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_StringList__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::list< sword::SWBuf >::size_type arg1 ;
  size_t val1 ;
  int ecode1 = 0 ;
  std::list< sword::SWBuf > *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_StringList" "', argument " "1"" of type '" "std::list< sword::SWBuf >::size_type""'");
  } 
  arg1 = static_cast< std::list< sword::SWBuf >::size_type >(val1);
  {
    try {
      result = (std::list< sword::SWBuf > *)new std::list< sword::SWBuf >(SWIG_STD_MOVE(arg1)); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__listT_sword__SWBuf_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringList_pop_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::list< sword::SWBuf > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__listT_sword__SWBuf_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringList_pop_back" "', argument " "1"" of type '" "std::list< sword::SWBuf > *""'"); 
  }
  arg1 = reinterpret_cast< std::list< sword::SWBuf > * >(argp1);
  {
    try {
      (arg1)->pop_back(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringList_resize__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::list< sword::SWBuf > *arg1 = 0 ;
  std::list< sword::SWBuf >::size_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__listT_sword__SWBuf_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringList_resize" "', argument " "1"" of type '" "std::list< sword::SWBuf > *""'"); 
  }
  arg1 = reinterpret_cast< std::list< sword::SWBuf > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StringList_resize" "', argument " "2"" of type '" "std::list< sword::SWBuf >::size_type""'");
  } 
  arg2 = static_cast< std::list< sword::SWBuf >::size_type >(val2);
  {
    try {
      (arg1)->resize(SWIG_STD_MOVE(arg2)); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringList_erase__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::list< sword::SWBuf > *arg1 = 0 ;
  std::list< sword::SWBuf >::iterator arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  std::list< sword::SWBuf >::iterator result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__listT_sword__SWBuf_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringList_erase" "', argument " "1"" of type '" "std::list< sword::SWBuf > *""'"); 
  }
  arg1 = reinterpret_cast< std::list< sword::SWBuf > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "StringList_erase" "', argument " "2"" of type '" "std::list< sword::SWBuf >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::list< sword::SWBuf >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::list< sword::SWBuf >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "StringList_erase" "', argument " "2"" of type '" "std::list< sword::SWBuf >::iterator""'");
    }
  }
  {
    try {
      result = std_list_Sl_sword_SWBuf_Sg__erase__SWIG_0(arg1,SWIG_STD_MOVE(arg2)); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::list< sword::SWBuf >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringList_erase__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::list< sword::SWBuf > *arg1 = 0 ;
  std::list< sword::SWBuf >::iterator arg2 ;
  std::list< sword::SWBuf >::iterator arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  swig::SwigPyIterator *iter3 = 0 ;
  int res3 ;
  std::list< sword::SWBuf >::iterator result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__listT_sword__SWBuf_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringList_erase" "', argument " "1"" of type '" "std::list< sword::SWBuf > *""'"); 
  }
  arg1 = reinterpret_cast< std::list< sword::SWBuf > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "StringList_erase" "', argument " "2"" of type '" "std::list< sword::SWBuf >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::list< sword::SWBuf >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::list< sword::SWBuf >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "StringList_erase" "', argument " "2"" of type '" "std::list< sword::SWBuf >::iterator""'");
    }
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], SWIG_as_voidptrptr(&iter3), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res3) || !iter3) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "StringList_erase" "', argument " "3"" of type '" "std::list< sword::SWBuf >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::list< sword::SWBuf >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::list< sword::SWBuf >::iterator > *>(iter3);
    if (iter_t) {
      arg3 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "StringList_erase" "', argument " "3"" of type '" "std::list< sword::SWBuf >::iterator""'");
    }
  }
  {
    try {
      result = std_list_Sl_sword_SWBuf_Sg__erase__SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3)); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::list< sword::SWBuf >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringList_erase(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "StringList_erase", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::list< sword::SWBuf,std::allocator< sword::SWBuf > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::list< sword::SWBuf >::iterator > *>(iter) != 0));
      if (_v) {
        return _wrap_StringList_erase__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::list< sword::SWBuf,std::allocator< sword::SWBuf > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::list< sword::SWBuf >::iterator > *>(iter) != 0));
      if (_v) {
        swig::SwigPyIterator *iter = 0;
        int res = SWIG_ConvertPtr(argv[2], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
        _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::list< sword::SWBuf >::iterator > *>(iter) != 0));
        if (_v) {
          return _wrap_StringList_erase__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'StringList_erase'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::list< sword::SWBuf >::erase(std::list< sword::SWBuf >::iterator)\n"
    "    std::list< sword::SWBuf >::erase(std::list< sword::SWBuf >::iterator,std::list< sword::SWBuf >::iterator)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_new_StringList__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::list< sword::SWBuf >::size_type arg1 ;
  std::list< sword::SWBuf >::value_type *arg2 = 0 ;
  size_t val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  std::list< sword::SWBuf > *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_StringList" "', argument " "1"" of type '" "std::list< sword::SWBuf >::size_type""'");
  } 
  arg1 = static_cast< std::list< sword::SWBuf >::size_type >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_sword__SWBuf,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_StringList" "', argument " "2"" of type '" "std::list< sword::SWBuf >::value_type const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_StringList" "', argument " "2"" of type '" "std::list< sword::SWBuf >::value_type const &""'"); 
  }
  arg2 = reinterpret_cast< std::list< sword::SWBuf >::value_type * >(argp2);
  {
    try {
      result = (std::list< sword::SWBuf > *)new std::list< sword::SWBuf >(SWIG_STD_MOVE(arg1),(std::list< sword::SWBuf >::value_type const &)*arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__listT_sword__SWBuf_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_StringList(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_StringList", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_StringList__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_StringList__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::list< sword::SWBuf,std::allocator< sword::SWBuf > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_StringList__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_sword__SWBuf, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_StringList__SWIG_3(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_StringList'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::list< sword::SWBuf >::list()\n"
    "    std::list< sword::SWBuf >::list(std::list< sword::SWBuf > const &)\n"
    "    std::list< sword::SWBuf >::list(std::list< sword::SWBuf >::size_type)\n"
    "    std::list< sword::SWBuf >::list(std::list< sword::SWBuf >::size_type,std::list< sword::SWBuf >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_StringList_push_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::list< sword::SWBuf > *arg1 = 0 ;
  std::list< sword::SWBuf >::value_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "StringList_push_back", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__listT_sword__SWBuf_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringList_push_back" "', argument " "1"" of type '" "std::list< sword::SWBuf > *""'"); 
  }
  arg1 = reinterpret_cast< std::list< sword::SWBuf > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_sword__SWBuf,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StringList_push_back" "', argument " "2"" of type '" "std::list< sword::SWBuf >::value_type const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "StringList_push_back" "', argument " "2"" of type '" "std::list< sword::SWBuf >::value_type const &""'"); 
  }
  arg2 = reinterpret_cast< std::list< sword::SWBuf >::value_type * >(argp2);
  {
    try {
      (arg1)->push_back((std::list< sword::SWBuf >::value_type const &)*arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringList_front(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::list< sword::SWBuf > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::list< sword::SWBuf >::value_type *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__listT_sword__SWBuf_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringList_front" "', argument " "1"" of type '" "std::list< sword::SWBuf > const *""'"); 
  }
  arg1 = reinterpret_cast< std::list< sword::SWBuf > * >(argp1);
  {
    try {
      result = (std::list< sword::SWBuf >::value_type *) &((std::list< sword::SWBuf > const *)arg1)->front(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__SWBuf, 0 |  0 );
  if (!swig::container_owner<swig::traits<std::list< sword::SWBuf >::value_type>::category>::back_reference(resultobj, swig_obj[0]) && PyErr_Occurred()) {
    SWIG_fail;
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringList_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::list< sword::SWBuf > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::list< sword::SWBuf >::value_type *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__listT_sword__SWBuf_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringList_back" "', argument " "1"" of type '" "std::list< sword::SWBuf > const *""'"); 
  }
  arg1 = reinterpret_cast< std::list< sword::SWBuf > * >(argp1);
  {
    try {
      result = (std::list< sword::SWBuf >::value_type *) &((std::list< sword::SWBuf > const *)arg1)->back(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__SWBuf, 0 |  0 );
  if (!swig::container_owner<swig::traits<std::list< sword::SWBuf >::value_type>::category>::back_reference(resultobj, swig_obj[0]) && PyErr_Occurred()) {
    SWIG_fail;
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringList_assign(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::list< sword::SWBuf > *arg1 = 0 ;
  std::list< sword::SWBuf >::size_type arg2 ;
  std::list< sword::SWBuf >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "StringList_assign", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__listT_sword__SWBuf_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringList_assign" "', argument " "1"" of type '" "std::list< sword::SWBuf > *""'"); 
  }
  arg1 = reinterpret_cast< std::list< sword::SWBuf > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StringList_assign" "', argument " "2"" of type '" "std::list< sword::SWBuf >::size_type""'");
  } 
  arg2 = static_cast< std::list< sword::SWBuf >::size_type >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_sword__SWBuf,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "StringList_assign" "', argument " "3"" of type '" "std::list< sword::SWBuf >::value_type const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "StringList_assign" "', argument " "3"" of type '" "std::list< sword::SWBuf >::value_type const &""'"); 
  }
  arg3 = reinterpret_cast< std::list< sword::SWBuf >::value_type * >(argp3);
  {
    try {
      (arg1)->assign(SWIG_STD_MOVE(arg2),(std::list< sword::SWBuf >::value_type const &)*arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringList_resize__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::list< sword::SWBuf > *arg1 = 0 ;
  std::list< sword::SWBuf >::size_type arg2 ;
  std::list< sword::SWBuf >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__listT_sword__SWBuf_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringList_resize" "', argument " "1"" of type '" "std::list< sword::SWBuf > *""'"); 
  }
  arg1 = reinterpret_cast< std::list< sword::SWBuf > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StringList_resize" "', argument " "2"" of type '" "std::list< sword::SWBuf >::size_type""'");
  } 
  arg2 = static_cast< std::list< sword::SWBuf >::size_type >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_sword__SWBuf,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "StringList_resize" "', argument " "3"" of type '" "std::list< sword::SWBuf >::value_type const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "StringList_resize" "', argument " "3"" of type '" "std::list< sword::SWBuf >::value_type const &""'"); 
  }
  arg3 = reinterpret_cast< std::list< sword::SWBuf >::value_type * >(argp3);
  {
    try {
      (arg1)->resize(SWIG_STD_MOVE(arg2),(std::list< sword::SWBuf >::value_type const &)*arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringList_resize(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "StringList_resize", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::list< sword::SWBuf,std::allocator< sword::SWBuf > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_StringList_resize__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::list< sword::SWBuf,std::allocator< sword::SWBuf > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_sword__SWBuf, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_StringList_resize__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'StringList_resize'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::list< sword::SWBuf >::resize(std::list< sword::SWBuf >::size_type)\n"
    "    std::list< sword::SWBuf >::resize(std::list< sword::SWBuf >::size_type,std::list< sword::SWBuf >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_StringList_insert__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::list< sword::SWBuf > *arg1 = 0 ;
  std::list< sword::SWBuf >::iterator arg2 ;
  std::list< sword::SWBuf >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  std::list< sword::SWBuf >::iterator result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__listT_sword__SWBuf_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringList_insert" "', argument " "1"" of type '" "std::list< sword::SWBuf > *""'"); 
  }
  arg1 = reinterpret_cast< std::list< sword::SWBuf > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "StringList_insert" "', argument " "2"" of type '" "std::list< sword::SWBuf >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::list< sword::SWBuf >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::list< sword::SWBuf >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "StringList_insert" "', argument " "2"" of type '" "std::list< sword::SWBuf >::iterator""'");
    }
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_sword__SWBuf,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "StringList_insert" "', argument " "3"" of type '" "std::list< sword::SWBuf >::value_type const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "StringList_insert" "', argument " "3"" of type '" "std::list< sword::SWBuf >::value_type const &""'"); 
  }
  arg3 = reinterpret_cast< std::list< sword::SWBuf >::value_type * >(argp3);
  {
    try {
      result = std_list_Sl_sword_SWBuf_Sg__insert__SWIG_0(arg1,SWIG_STD_MOVE(arg2),(sword::SWBuf const &)*arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::list< sword::SWBuf >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringList_insert__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::list< sword::SWBuf > *arg1 = 0 ;
  std::list< sword::SWBuf >::iterator arg2 ;
  std::list< sword::SWBuf >::size_type arg3 ;
  std::list< sword::SWBuf >::value_type *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  size_t val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__listT_sword__SWBuf_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringList_insert" "', argument " "1"" of type '" "std::list< sword::SWBuf > *""'"); 
  }
  arg1 = reinterpret_cast< std::list< sword::SWBuf > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "StringList_insert" "', argument " "2"" of type '" "std::list< sword::SWBuf >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::list< sword::SWBuf >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::list< sword::SWBuf >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "StringList_insert" "', argument " "2"" of type '" "std::list< sword::SWBuf >::iterator""'");
    }
  }
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "StringList_insert" "', argument " "3"" of type '" "std::list< sword::SWBuf >::size_type""'");
  } 
  arg3 = static_cast< std::list< sword::SWBuf >::size_type >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_sword__SWBuf,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "StringList_insert" "', argument " "4"" of type '" "std::list< sword::SWBuf >::value_type const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "StringList_insert" "', argument " "4"" of type '" "std::list< sword::SWBuf >::value_type const &""'"); 
  }
  arg4 = reinterpret_cast< std::list< sword::SWBuf >::value_type * >(argp4);
  {
    try {
      std_list_Sl_sword_SWBuf_Sg__insert__SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),(sword::SWBuf const &)*arg4); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringList_insert(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "StringList_insert", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::list< sword::SWBuf,std::allocator< sword::SWBuf > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::list< sword::SWBuf >::iterator > *>(iter) != 0));
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_sword__SWBuf, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_StringList_insert__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::list< sword::SWBuf,std::allocator< sword::SWBuf > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::list< sword::SWBuf >::iterator > *>(iter) != 0));
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_sword__SWBuf, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_StringList_insert__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'StringList_insert'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::list< sword::SWBuf >::insert(std::list< sword::SWBuf >::iterator,std::list< sword::SWBuf >::value_type const &)\n"
    "    std::list< sword::SWBuf >::insert(std::list< sword::SWBuf >::iterator,std::list< sword::SWBuf >::size_type,std::list< sword::SWBuf >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_StringList_pop_front(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::list< sword::SWBuf > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__listT_sword__SWBuf_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringList_pop_front" "', argument " "1"" of type '" "std::list< sword::SWBuf > *""'"); 
  }
  arg1 = reinterpret_cast< std::list< sword::SWBuf > * >(argp1);
  {
    try {
      (arg1)->pop_front(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringList_push_front(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::list< sword::SWBuf > *arg1 = 0 ;
  std::list< sword::SWBuf >::value_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "StringList_push_front", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__listT_sword__SWBuf_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringList_push_front" "', argument " "1"" of type '" "std::list< sword::SWBuf > *""'"); 
  }
  arg1 = reinterpret_cast< std::list< sword::SWBuf > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_sword__SWBuf,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StringList_push_front" "', argument " "2"" of type '" "std::list< sword::SWBuf >::value_type const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "StringList_push_front" "', argument " "2"" of type '" "std::list< sword::SWBuf >::value_type const &""'"); 
  }
  arg2 = reinterpret_cast< std::list< sword::SWBuf >::value_type * >(argp2);
  {
    try {
      (arg1)->push_front((std::list< sword::SWBuf >::value_type const &)*arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringList_reverse(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::list< sword::SWBuf > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__listT_sword__SWBuf_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringList_reverse" "', argument " "1"" of type '" "std::list< sword::SWBuf > *""'"); 
  }
  arg1 = reinterpret_cast< std::list< sword::SWBuf > * >(argp1);
  {
    try {
      (arg1)->reverse(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_StringList(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::list< sword::SWBuf > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__listT_sword__SWBuf_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_StringList" "', argument " "1"" of type '" "std::list< sword::SWBuf > *""'"); 
  }
  arg1 = reinterpret_cast< std::list< sword::SWBuf > * >(argp1);
  {
    try {
      delete arg1; 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *StringList_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__listT_sword__SWBuf_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *StringList_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_InstallSourceMap__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::less< sword::SWBuf > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::map< sword::SWBuf,sword::InstallSource * > *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_std__lessT_sword__SWBuf_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_InstallSourceMap" "', argument " "1"" of type '" "std::less< sword::SWBuf > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_InstallSourceMap" "', argument " "1"" of type '" "std::less< sword::SWBuf > const &""'"); 
  }
  arg1 = reinterpret_cast< std::less< sword::SWBuf > * >(argp1);
  {
    try {
      result = (std::map< sword::SWBuf,sword::InstallSource * > *)new std::map< sword::SWBuf,sword::InstallSource * >((std::less< sword::SWBuf > const &)*arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__mapT_sword__SWBuf_sword__InstallSource_p_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InstallSourceMap_iterator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::map< sword::SWBuf,sword::InstallSource * > *arg1 = 0 ;
  PyObject **arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  swig::SwigPyIterator *result = 0 ;
  
  arg2 = &swig_obj[0];
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_sword__SWBuf_sword__InstallSource_p_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InstallSourceMap_iterator" "', argument " "1"" of type '" "std::map< sword::SWBuf,sword::InstallSource * > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< sword::SWBuf,sword::InstallSource * > * >(argp1);
  {
    try {
      result = (swig::SwigPyIterator *)std_map_Sl_sword_SWBuf_Sc_sword_InstallSource_Sm__Sg__iterator(arg1,arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  if (!result) SWIG_fail;
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InstallSourceMap___nonzero__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::map< sword::SWBuf,sword::InstallSource * > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_sword__SWBuf_sword__InstallSource_p_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InstallSourceMap___nonzero__" "', argument " "1"" of type '" "std::map< sword::SWBuf,sword::InstallSource * > const *""'"); 
  }
  arg1 = reinterpret_cast< std::map< sword::SWBuf,sword::InstallSource * > * >(argp1);
  {
    try {
      result = (bool)std_map_Sl_sword_SWBuf_Sc_sword_InstallSource_Sm__Sg____nonzero__((std::map< sword::SWBuf,sword::InstallSource * > const *)arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InstallSourceMap___bool__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::map< sword::SWBuf,sword::InstallSource * > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_sword__SWBuf_sword__InstallSource_p_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InstallSourceMap___bool__" "', argument " "1"" of type '" "std::map< sword::SWBuf,sword::InstallSource * > const *""'"); 
  }
  arg1 = reinterpret_cast< std::map< sword::SWBuf,sword::InstallSource * > * >(argp1);
  {
    try {
      result = (bool)std_map_Sl_sword_SWBuf_Sc_sword_InstallSource_Sm__Sg____bool__((std::map< sword::SWBuf,sword::InstallSource * > const *)arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InstallSourceMap___len__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::map< sword::SWBuf,sword::InstallSource * > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::map< sword::SWBuf,sword::InstallSource * >::size_type result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_sword__SWBuf_sword__InstallSource_p_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InstallSourceMap___len__" "', argument " "1"" of type '" "std::map< sword::SWBuf,sword::InstallSource * > const *""'"); 
  }
  arg1 = reinterpret_cast< std::map< sword::SWBuf,sword::InstallSource * > * >(argp1);
  {
    try {
      result = std_map_Sl_sword_SWBuf_Sc_sword_InstallSource_Sm__Sg____len__((std::map< sword::SWBuf,sword::InstallSource * > const *)arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InstallSourceMap___getitem__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::map< sword::SWBuf,sword::InstallSource * > *arg1 = 0 ;
  std::map< sword::SWBuf,sword::InstallSource * >::key_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  std::map< sword::SWBuf,sword::InstallSource * >::mapped_type *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "InstallSourceMap___getitem__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_sword__SWBuf_sword__InstallSource_p_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InstallSourceMap___getitem__" "', argument " "1"" of type '" "std::map< sword::SWBuf,sword::InstallSource * > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< sword::SWBuf,sword::InstallSource * > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_sword__SWBuf,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InstallSourceMap___getitem__" "', argument " "2"" of type '" "std::map< sword::SWBuf,sword::InstallSource * >::key_type const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "InstallSourceMap___getitem__" "', argument " "2"" of type '" "std::map< sword::SWBuf,sword::InstallSource * >::key_type const &""'"); 
  }
  arg2 = reinterpret_cast< std::map< sword::SWBuf,sword::InstallSource * >::key_type * >(argp2);
  {
    try {
      try {
        result = (std::map< sword::SWBuf,sword::InstallSource * >::mapped_type *) &std_map_Sl_sword_SWBuf_Sc_sword_InstallSource_Sm__Sg____getitem__(arg1,(sword::SWBuf const &)*arg2);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(*result), SWIGTYPE_p_sword__InstallSource, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InstallSourceMap___delitem__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::map< sword::SWBuf,sword::InstallSource * > *arg1 = 0 ;
  std::map< sword::SWBuf,sword::InstallSource * >::key_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "InstallSourceMap___delitem__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_sword__SWBuf_sword__InstallSource_p_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InstallSourceMap___delitem__" "', argument " "1"" of type '" "std::map< sword::SWBuf,sword::InstallSource * > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< sword::SWBuf,sword::InstallSource * > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_sword__SWBuf,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InstallSourceMap___delitem__" "', argument " "2"" of type '" "std::map< sword::SWBuf,sword::InstallSource * >::key_type const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "InstallSourceMap___delitem__" "', argument " "2"" of type '" "std::map< sword::SWBuf,sword::InstallSource * >::key_type const &""'"); 
  }
  arg2 = reinterpret_cast< std::map< sword::SWBuf,sword::InstallSource * >::key_type * >(argp2);
  {
    try {
      try {
        std_map_Sl_sword_SWBuf_Sc_sword_InstallSource_Sm__Sg____delitem__(arg1,(sword::SWBuf const &)*arg2);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InstallSourceMap_has_key(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::map< sword::SWBuf,sword::InstallSource * > *arg1 = 0 ;
  std::map< sword::SWBuf,sword::InstallSource * >::key_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "InstallSourceMap_has_key", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_sword__SWBuf_sword__InstallSource_p_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InstallSourceMap_has_key" "', argument " "1"" of type '" "std::map< sword::SWBuf,sword::InstallSource * > const *""'"); 
  }
  arg1 = reinterpret_cast< std::map< sword::SWBuf,sword::InstallSource * > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_sword__SWBuf,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InstallSourceMap_has_key" "', argument " "2"" of type '" "std::map< sword::SWBuf,sword::InstallSource * >::key_type const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "InstallSourceMap_has_key" "', argument " "2"" of type '" "std::map< sword::SWBuf,sword::InstallSource * >::key_type const &""'"); 
  }
  arg2 = reinterpret_cast< std::map< sword::SWBuf,sword::InstallSource * >::key_type * >(argp2);
  {
    try {
      result = (bool)std_map_Sl_sword_SWBuf_Sc_sword_InstallSource_Sm__Sg__has_key((std::map< sword::SWBuf,sword::InstallSource * > const *)arg1,(sword::SWBuf const &)*arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InstallSourceMap_keys(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::map< sword::SWBuf,sword::InstallSource * > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_sword__SWBuf_sword__InstallSource_p_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InstallSourceMap_keys" "', argument " "1"" of type '" "std::map< sword::SWBuf,sword::InstallSource * > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< sword::SWBuf,sword::InstallSource * > * >(argp1);
  {
    try {
      result = (PyObject *)std_map_Sl_sword_SWBuf_Sc_sword_InstallSource_Sm__Sg__keys(arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = result;
  if (!resultobj) SWIG_fail;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InstallSourceMap_values(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::map< sword::SWBuf,sword::InstallSource * > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_sword__SWBuf_sword__InstallSource_p_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InstallSourceMap_values" "', argument " "1"" of type '" "std::map< sword::SWBuf,sword::InstallSource * > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< sword::SWBuf,sword::InstallSource * > * >(argp1);
  {
    try {
      result = (PyObject *)std_map_Sl_sword_SWBuf_Sc_sword_InstallSource_Sm__Sg__values(arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = result;
  if (!resultobj) SWIG_fail;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InstallSourceMap_items(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::map< sword::SWBuf,sword::InstallSource * > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_sword__SWBuf_sword__InstallSource_p_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InstallSourceMap_items" "', argument " "1"" of type '" "std::map< sword::SWBuf,sword::InstallSource * > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< sword::SWBuf,sword::InstallSource * > * >(argp1);
  {
    try {
      result = (PyObject *)std_map_Sl_sword_SWBuf_Sc_sword_InstallSource_Sm__Sg__items(arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = result;
  if (!resultobj) SWIG_fail;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InstallSourceMap___contains__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::map< sword::SWBuf,sword::InstallSource * > *arg1 = 0 ;
  std::map< sword::SWBuf,sword::InstallSource * >::key_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "InstallSourceMap___contains__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_sword__SWBuf_sword__InstallSource_p_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InstallSourceMap___contains__" "', argument " "1"" of type '" "std::map< sword::SWBuf,sword::InstallSource * > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< sword::SWBuf,sword::InstallSource * > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_sword__SWBuf,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InstallSourceMap___contains__" "', argument " "2"" of type '" "std::map< sword::SWBuf,sword::InstallSource * >::key_type const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "InstallSourceMap___contains__" "', argument " "2"" of type '" "std::map< sword::SWBuf,sword::InstallSource * >::key_type const &""'"); 
  }
  arg2 = reinterpret_cast< std::map< sword::SWBuf,sword::InstallSource * >::key_type * >(argp2);
  {
    try {
      result = (bool)std_map_Sl_sword_SWBuf_Sc_sword_InstallSource_Sm__Sg____contains__(arg1,(sword::SWBuf const &)*arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InstallSourceMap_key_iterator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::map< sword::SWBuf,sword::InstallSource * > *arg1 = 0 ;
  PyObject **arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  swig::SwigPyIterator *result = 0 ;
  
  arg2 = &swig_obj[0];
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_sword__SWBuf_sword__InstallSource_p_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InstallSourceMap_key_iterator" "', argument " "1"" of type '" "std::map< sword::SWBuf,sword::InstallSource * > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< sword::SWBuf,sword::InstallSource * > * >(argp1);
  {
    try {
      result = (swig::SwigPyIterator *)std_map_Sl_sword_SWBuf_Sc_sword_InstallSource_Sm__Sg__key_iterator(arg1,arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  if (!result) SWIG_fail;
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InstallSourceMap_value_iterator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::map< sword::SWBuf,sword::InstallSource * > *arg1 = 0 ;
  PyObject **arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  swig::SwigPyIterator *result = 0 ;
  
  arg2 = &swig_obj[0];
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_sword__SWBuf_sword__InstallSource_p_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InstallSourceMap_value_iterator" "', argument " "1"" of type '" "std::map< sword::SWBuf,sword::InstallSource * > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< sword::SWBuf,sword::InstallSource * > * >(argp1);
  {
    try {
      result = (swig::SwigPyIterator *)std_map_Sl_sword_SWBuf_Sc_sword_InstallSource_Sm__Sg__value_iterator(arg1,arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  if (!result) SWIG_fail;
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InstallSourceMap___setitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::map< sword::SWBuf,sword::InstallSource * > *arg1 = 0 ;
  std::map< sword::SWBuf,sword::InstallSource * >::key_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_sword__SWBuf_sword__InstallSource_p_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InstallSourceMap___setitem__" "', argument " "1"" of type '" "std::map< sword::SWBuf,sword::InstallSource * > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< sword::SWBuf,sword::InstallSource * > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_sword__SWBuf,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InstallSourceMap___setitem__" "', argument " "2"" of type '" "std::map< sword::SWBuf,sword::InstallSource * >::key_type const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "InstallSourceMap___setitem__" "', argument " "2"" of type '" "std::map< sword::SWBuf,sword::InstallSource * >::key_type const &""'"); 
  }
  arg2 = reinterpret_cast< std::map< sword::SWBuf,sword::InstallSource * >::key_type * >(argp2);
  {
    try {
      std_map_Sl_sword_SWBuf_Sc_sword_InstallSource_Sm__Sg____setitem____SWIG_0(arg1,(sword::SWBuf const &)*arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InstallSourceMap___setitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::map< sword::SWBuf,sword::InstallSource * > *arg1 = 0 ;
  std::map< sword::SWBuf,sword::InstallSource * >::key_type *arg2 = 0 ;
  std::map< sword::SWBuf,sword::InstallSource * >::mapped_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  std::map< sword::SWBuf,sword::InstallSource * >::mapped_type temp3 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_sword__SWBuf_sword__InstallSource_p_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InstallSourceMap___setitem__" "', argument " "1"" of type '" "std::map< sword::SWBuf,sword::InstallSource * > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< sword::SWBuf,sword::InstallSource * > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_sword__SWBuf,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InstallSourceMap___setitem__" "', argument " "2"" of type '" "std::map< sword::SWBuf,sword::InstallSource * >::key_type const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "InstallSourceMap___setitem__" "', argument " "2"" of type '" "std::map< sword::SWBuf,sword::InstallSource * >::key_type const &""'"); 
  }
  arg2 = reinterpret_cast< std::map< sword::SWBuf,sword::InstallSource * >::key_type * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_sword__InstallSource, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "InstallSourceMap___setitem__" "', argument " "3"" of type '" "std::map< sword::SWBuf,sword::InstallSource * >::mapped_type""'"); 
  }
  temp3 = reinterpret_cast< std::map< sword::SWBuf,sword::InstallSource * >::mapped_type >(argp3);
  arg3 = reinterpret_cast< std::map< sword::SWBuf,sword::InstallSource * >::mapped_type * >(&temp3);
  {
    try {
      try {
        std_map_Sl_sword_SWBuf_Sc_sword_InstallSource_Sm__Sg____setitem____SWIG_1(arg1,(sword::SWBuf const &)*arg2,(sword::InstallSource *const &)*arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InstallSourceMap___setitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "InstallSourceMap___setitem__", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::map< sword::SWBuf,sword::InstallSource *,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::InstallSource * > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_sword__SWBuf, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_InstallSourceMap___setitem____SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::map< sword::SWBuf,sword::InstallSource *,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::InstallSource * > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_sword__SWBuf, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_sword__InstallSource, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_InstallSourceMap___setitem____SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'InstallSourceMap___setitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::map< sword::SWBuf,sword::InstallSource * >::__setitem__(std::map< sword::SWBuf,sword::InstallSource * >::key_type const &)\n"
    "    std::map< sword::SWBuf,sword::InstallSource * >::__setitem__(std::map< sword::SWBuf,sword::InstallSource * >::key_type const &,std::map< sword::SWBuf,sword::InstallSource * >::mapped_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_InstallSourceMap_asdict(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::map< sword::SWBuf,sword::InstallSource * > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_sword__SWBuf_sword__InstallSource_p_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InstallSourceMap_asdict" "', argument " "1"" of type '" "std::map< sword::SWBuf,sword::InstallSource * > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< sword::SWBuf,sword::InstallSource * > * >(argp1);
  {
    try {
      result = (PyObject *)std_map_Sl_sword_SWBuf_Sc_sword_InstallSource_Sm__Sg__asdict(arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = result;
  if (!resultobj) SWIG_fail;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_InstallSourceMap__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  std::map< sword::SWBuf,sword::InstallSource * > *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (std::map< sword::SWBuf,sword::InstallSource * > *)new std::map< sword::SWBuf,sword::InstallSource * >(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__mapT_sword__SWBuf_sword__InstallSource_p_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_InstallSourceMap__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::map< sword::SWBuf,sword::InstallSource * > *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  std::map< sword::SWBuf,sword::InstallSource * > *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    std::map< sword::SWBuf,sword::InstallSource *,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::InstallSource * > > > *ptr = (std::map< sword::SWBuf,sword::InstallSource *,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::InstallSource * > > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_InstallSourceMap" "', argument " "1"" of type '" "std::map< sword::SWBuf,sword::InstallSource * > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_InstallSourceMap" "', argument " "1"" of type '" "std::map< sword::SWBuf,sword::InstallSource * > const &""'"); 
    }
    arg1 = ptr;
  }
  {
    try {
      result = (std::map< sword::SWBuf,sword::InstallSource * > *)new std::map< sword::SWBuf,sword::InstallSource * >((std::map< sword::SWBuf,sword::InstallSource * > const &)*arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__mapT_sword__SWBuf_sword__InstallSource_p_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_InstallSourceMap(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_InstallSourceMap", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_InstallSourceMap__SWIG_1(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_std__lessT_sword__SWBuf_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_InstallSourceMap__SWIG_0(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::map< sword::SWBuf,sword::InstallSource *,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::InstallSource * > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_InstallSourceMap__SWIG_2(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_InstallSourceMap'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::map< sword::SWBuf,sword::InstallSource * >::map(std::less< sword::SWBuf > const &)\n"
    "    std::map< sword::SWBuf,sword::InstallSource * >::map()\n"
    "    std::map< sword::SWBuf,sword::InstallSource * >::map(std::map< sword::SWBuf,sword::InstallSource * > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_InstallSourceMap_empty(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::map< sword::SWBuf,sword::InstallSource * > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_sword__SWBuf_sword__InstallSource_p_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InstallSourceMap_empty" "', argument " "1"" of type '" "std::map< sword::SWBuf,sword::InstallSource * > const *""'"); 
  }
  arg1 = reinterpret_cast< std::map< sword::SWBuf,sword::InstallSource * > * >(argp1);
  {
    try {
      result = (bool)((std::map< sword::SWBuf,sword::InstallSource * > const *)arg1)->empty(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InstallSourceMap_size(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::map< sword::SWBuf,sword::InstallSource * > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::map< sword::SWBuf,sword::InstallSource * >::size_type result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_sword__SWBuf_sword__InstallSource_p_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InstallSourceMap_size" "', argument " "1"" of type '" "std::map< sword::SWBuf,sword::InstallSource * > const *""'"); 
  }
  arg1 = reinterpret_cast< std::map< sword::SWBuf,sword::InstallSource * > * >(argp1);
  {
    try {
      result = ((std::map< sword::SWBuf,sword::InstallSource * > const *)arg1)->size(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InstallSourceMap_swap(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::map< sword::SWBuf,sword::InstallSource * > *arg1 = 0 ;
  std::map< sword::SWBuf,sword::InstallSource * > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "InstallSourceMap_swap", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_sword__SWBuf_sword__InstallSource_p_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InstallSourceMap_swap" "', argument " "1"" of type '" "std::map< sword::SWBuf,sword::InstallSource * > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< sword::SWBuf,sword::InstallSource * > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__mapT_sword__SWBuf_sword__InstallSource_p_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InstallSourceMap_swap" "', argument " "2"" of type '" "std::map< sword::SWBuf,sword::InstallSource * > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "InstallSourceMap_swap" "', argument " "2"" of type '" "std::map< sword::SWBuf,sword::InstallSource * > &""'"); 
  }
  arg2 = reinterpret_cast< std::map< sword::SWBuf,sword::InstallSource * > * >(argp2);
  {
    try {
      (arg1)->swap(*arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InstallSourceMap_begin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::map< sword::SWBuf,sword::InstallSource * > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::map< sword::SWBuf,sword::InstallSource * >::iterator result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_sword__SWBuf_sword__InstallSource_p_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InstallSourceMap_begin" "', argument " "1"" of type '" "std::map< sword::SWBuf,sword::InstallSource * > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< sword::SWBuf,sword::InstallSource * > * >(argp1);
  {
    try {
      result = (arg1)->begin(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::map< sword::SWBuf,sword::InstallSource * >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InstallSourceMap_end(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::map< sword::SWBuf,sword::InstallSource * > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::map< sword::SWBuf,sword::InstallSource * >::iterator result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_sword__SWBuf_sword__InstallSource_p_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InstallSourceMap_end" "', argument " "1"" of type '" "std::map< sword::SWBuf,sword::InstallSource * > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< sword::SWBuf,sword::InstallSource * > * >(argp1);
  {
    try {
      result = (arg1)->end(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::map< sword::SWBuf,sword::InstallSource * >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InstallSourceMap_rbegin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::map< sword::SWBuf,sword::InstallSource * > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::map< sword::SWBuf,sword::InstallSource * >::reverse_iterator result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_sword__SWBuf_sword__InstallSource_p_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InstallSourceMap_rbegin" "', argument " "1"" of type '" "std::map< sword::SWBuf,sword::InstallSource * > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< sword::SWBuf,sword::InstallSource * > * >(argp1);
  {
    try {
      result = (arg1)->rbegin(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::map< sword::SWBuf,sword::InstallSource * >::reverse_iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InstallSourceMap_rend(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::map< sword::SWBuf,sword::InstallSource * > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::map< sword::SWBuf,sword::InstallSource * >::reverse_iterator result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_sword__SWBuf_sword__InstallSource_p_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InstallSourceMap_rend" "', argument " "1"" of type '" "std::map< sword::SWBuf,sword::InstallSource * > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< sword::SWBuf,sword::InstallSource * > * >(argp1);
  {
    try {
      result = (arg1)->rend(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::map< sword::SWBuf,sword::InstallSource * >::reverse_iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InstallSourceMap_clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::map< sword::SWBuf,sword::InstallSource * > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_sword__SWBuf_sword__InstallSource_p_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InstallSourceMap_clear" "', argument " "1"" of type '" "std::map< sword::SWBuf,sword::InstallSource * > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< sword::SWBuf,sword::InstallSource * > * >(argp1);
  {
    try {
      (arg1)->clear(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InstallSourceMap_get_allocator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::map< sword::SWBuf,sword::InstallSource * > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< std::allocator< std::pair< sword::SWBuf const,sword::InstallSource * > > > result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_sword__SWBuf_sword__InstallSource_p_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InstallSourceMap_get_allocator" "', argument " "1"" of type '" "std::map< sword::SWBuf,sword::InstallSource * > const *""'"); 
  }
  arg1 = reinterpret_cast< std::map< sword::SWBuf,sword::InstallSource * > * >(argp1);
  {
    try {
      result = ((std::map< sword::SWBuf,sword::InstallSource * > const *)arg1)->get_allocator(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj((new std::map< sword::SWBuf,sword::InstallSource * >::allocator_type(result)), SWIGTYPE_p_std__allocatorT_std__pairT_sword__SWBuf_const_sword__InstallSource_p_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InstallSourceMap_erase__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::map< sword::SWBuf,sword::InstallSource * > *arg1 = 0 ;
  std::map< sword::SWBuf,sword::InstallSource * >::key_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  std::map< sword::SWBuf,sword::InstallSource * >::size_type result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_sword__SWBuf_sword__InstallSource_p_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InstallSourceMap_erase" "', argument " "1"" of type '" "std::map< sword::SWBuf,sword::InstallSource * > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< sword::SWBuf,sword::InstallSource * > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_sword__SWBuf,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InstallSourceMap_erase" "', argument " "2"" of type '" "std::map< sword::SWBuf,sword::InstallSource * >::key_type const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "InstallSourceMap_erase" "', argument " "2"" of type '" "std::map< sword::SWBuf,sword::InstallSource * >::key_type const &""'"); 
  }
  arg2 = reinterpret_cast< std::map< sword::SWBuf,sword::InstallSource * >::key_type * >(argp2);
  {
    try {
      result = (arg1)->erase((std::map< sword::SWBuf,sword::InstallSource * >::key_type const &)*arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InstallSourceMap_count(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::map< sword::SWBuf,sword::InstallSource * > *arg1 = 0 ;
  std::map< sword::SWBuf,sword::InstallSource * >::key_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  std::map< sword::SWBuf,sword::InstallSource * >::size_type result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "InstallSourceMap_count", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_sword__SWBuf_sword__InstallSource_p_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InstallSourceMap_count" "', argument " "1"" of type '" "std::map< sword::SWBuf,sword::InstallSource * > const *""'"); 
  }
  arg1 = reinterpret_cast< std::map< sword::SWBuf,sword::InstallSource * > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_sword__SWBuf,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InstallSourceMap_count" "', argument " "2"" of type '" "std::map< sword::SWBuf,sword::InstallSource * >::key_type const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "InstallSourceMap_count" "', argument " "2"" of type '" "std::map< sword::SWBuf,sword::InstallSource * >::key_type const &""'"); 
  }
  arg2 = reinterpret_cast< std::map< sword::SWBuf,sword::InstallSource * >::key_type * >(argp2);
  {
    try {
      result = ((std::map< sword::SWBuf,sword::InstallSource * > const *)arg1)->count((std::map< sword::SWBuf,sword::InstallSource * >::key_type const &)*arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InstallSourceMap_erase__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::map< sword::SWBuf,sword::InstallSource * > *arg1 = 0 ;
  std::map< sword::SWBuf,sword::InstallSource * >::iterator arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_sword__SWBuf_sword__InstallSource_p_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InstallSourceMap_erase" "', argument " "1"" of type '" "std::map< sword::SWBuf,sword::InstallSource * > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< sword::SWBuf,sword::InstallSource * > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "InstallSourceMap_erase" "', argument " "2"" of type '" "std::map< sword::SWBuf,sword::InstallSource * >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::map< sword::SWBuf,sword::InstallSource * >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::map< sword::SWBuf,sword::InstallSource * >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "InstallSourceMap_erase" "', argument " "2"" of type '" "std::map< sword::SWBuf,sword::InstallSource * >::iterator""'");
    }
  }
  {
    try {
      std_map_Sl_sword_SWBuf_Sc_sword_InstallSource_Sm__Sg__erase__SWIG_1(arg1,SWIG_STD_MOVE(arg2)); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InstallSourceMap_erase__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::map< sword::SWBuf,sword::InstallSource * > *arg1 = 0 ;
  std::map< sword::SWBuf,sword::InstallSource * >::iterator arg2 ;
  std::map< sword::SWBuf,sword::InstallSource * >::iterator arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  swig::SwigPyIterator *iter3 = 0 ;
  int res3 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_sword__SWBuf_sword__InstallSource_p_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InstallSourceMap_erase" "', argument " "1"" of type '" "std::map< sword::SWBuf,sword::InstallSource * > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< sword::SWBuf,sword::InstallSource * > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "InstallSourceMap_erase" "', argument " "2"" of type '" "std::map< sword::SWBuf,sword::InstallSource * >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::map< sword::SWBuf,sword::InstallSource * >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::map< sword::SWBuf,sword::InstallSource * >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "InstallSourceMap_erase" "', argument " "2"" of type '" "std::map< sword::SWBuf,sword::InstallSource * >::iterator""'");
    }
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], SWIG_as_voidptrptr(&iter3), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res3) || !iter3) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "InstallSourceMap_erase" "', argument " "3"" of type '" "std::map< sword::SWBuf,sword::InstallSource * >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::map< sword::SWBuf,sword::InstallSource * >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::map< sword::SWBuf,sword::InstallSource * >::iterator > *>(iter3);
    if (iter_t) {
      arg3 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "InstallSourceMap_erase" "', argument " "3"" of type '" "std::map< sword::SWBuf,sword::InstallSource * >::iterator""'");
    }
  }
  {
    try {
      std_map_Sl_sword_SWBuf_Sc_sword_InstallSource_Sm__Sg__erase__SWIG_2(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3)); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InstallSourceMap_erase(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "InstallSourceMap_erase", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::map< sword::SWBuf,sword::InstallSource *,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::InstallSource * > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_sword__SWBuf, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_InstallSourceMap_erase__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::map< sword::SWBuf,sword::InstallSource *,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::InstallSource * > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::map< sword::SWBuf,sword::InstallSource * >::iterator > *>(iter) != 0));
      if (_v) {
        return _wrap_InstallSourceMap_erase__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::map< sword::SWBuf,sword::InstallSource *,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::InstallSource * > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::map< sword::SWBuf,sword::InstallSource * >::iterator > *>(iter) != 0));
      if (_v) {
        swig::SwigPyIterator *iter = 0;
        int res = SWIG_ConvertPtr(argv[2], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
        _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::map< sword::SWBuf,sword::InstallSource * >::iterator > *>(iter) != 0));
        if (_v) {
          return _wrap_InstallSourceMap_erase__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'InstallSourceMap_erase'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::map< sword::SWBuf,sword::InstallSource * >::erase(std::map< sword::SWBuf,sword::InstallSource * >::key_type const &)\n"
    "    std::map< sword::SWBuf,sword::InstallSource * >::erase(std::map< sword::SWBuf,sword::InstallSource * >::iterator)\n"
    "    std::map< sword::SWBuf,sword::InstallSource * >::erase(std::map< sword::SWBuf,sword::InstallSource * >::iterator,std::map< sword::SWBuf,sword::InstallSource * >::iterator)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_InstallSourceMap_find(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::map< sword::SWBuf,sword::InstallSource * > *arg1 = 0 ;
  std::map< sword::SWBuf,sword::InstallSource * >::key_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  std::map< sword::SWBuf,sword::InstallSource * >::iterator result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "InstallSourceMap_find", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_sword__SWBuf_sword__InstallSource_p_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InstallSourceMap_find" "', argument " "1"" of type '" "std::map< sword::SWBuf,sword::InstallSource * > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< sword::SWBuf,sword::InstallSource * > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_sword__SWBuf,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InstallSourceMap_find" "', argument " "2"" of type '" "std::map< sword::SWBuf,sword::InstallSource * >::key_type const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "InstallSourceMap_find" "', argument " "2"" of type '" "std::map< sword::SWBuf,sword::InstallSource * >::key_type const &""'"); 
  }
  arg2 = reinterpret_cast< std::map< sword::SWBuf,sword::InstallSource * >::key_type * >(argp2);
  {
    try {
      result = (arg1)->find((std::map< sword::SWBuf,sword::InstallSource * >::key_type const &)*arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::map< sword::SWBuf,sword::InstallSource * >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InstallSourceMap_lower_bound(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::map< sword::SWBuf,sword::InstallSource * > *arg1 = 0 ;
  std::map< sword::SWBuf,sword::InstallSource * >::key_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  std::map< sword::SWBuf,sword::InstallSource * >::iterator result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "InstallSourceMap_lower_bound", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_sword__SWBuf_sword__InstallSource_p_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InstallSourceMap_lower_bound" "', argument " "1"" of type '" "std::map< sword::SWBuf,sword::InstallSource * > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< sword::SWBuf,sword::InstallSource * > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_sword__SWBuf,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InstallSourceMap_lower_bound" "', argument " "2"" of type '" "std::map< sword::SWBuf,sword::InstallSource * >::key_type const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "InstallSourceMap_lower_bound" "', argument " "2"" of type '" "std::map< sword::SWBuf,sword::InstallSource * >::key_type const &""'"); 
  }
  arg2 = reinterpret_cast< std::map< sword::SWBuf,sword::InstallSource * >::key_type * >(argp2);
  {
    try {
      result = (arg1)->lower_bound((std::map< sword::SWBuf,sword::InstallSource * >::key_type const &)*arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::map< sword::SWBuf,sword::InstallSource * >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InstallSourceMap_upper_bound(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::map< sword::SWBuf,sword::InstallSource * > *arg1 = 0 ;
  std::map< sword::SWBuf,sword::InstallSource * >::key_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  std::map< sword::SWBuf,sword::InstallSource * >::iterator result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "InstallSourceMap_upper_bound", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_sword__SWBuf_sword__InstallSource_p_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InstallSourceMap_upper_bound" "', argument " "1"" of type '" "std::map< sword::SWBuf,sword::InstallSource * > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< sword::SWBuf,sword::InstallSource * > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_sword__SWBuf,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InstallSourceMap_upper_bound" "', argument " "2"" of type '" "std::map< sword::SWBuf,sword::InstallSource * >::key_type const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "InstallSourceMap_upper_bound" "', argument " "2"" of type '" "std::map< sword::SWBuf,sword::InstallSource * >::key_type const &""'"); 
  }
  arg2 = reinterpret_cast< std::map< sword::SWBuf,sword::InstallSource * >::key_type * >(argp2);
  {
    try {
      result = (arg1)->upper_bound((std::map< sword::SWBuf,sword::InstallSource * >::key_type const &)*arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::map< sword::SWBuf,sword::InstallSource * >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_InstallSourceMap(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::map< sword::SWBuf,sword::InstallSource * > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_sword__SWBuf_sword__InstallSource_p_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_InstallSourceMap" "', argument " "1"" of type '" "std::map< sword::SWBuf,sword::InstallSource * > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< sword::SWBuf,sword::InstallSource * > * >(argp1);
  {
    try {
      delete arg1; 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *InstallSourceMap_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__mapT_sword__SWBuf_sword__InstallSource_p_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *InstallSourceMap_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_DirEntryVector_iterator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< sword::DirEntry > *arg1 = 0 ;
  PyObject **arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  swig::SwigPyIterator *result = 0 ;
  
  arg2 = &swig_obj[0];
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_sword__DirEntry_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DirEntryVector_iterator" "', argument " "1"" of type '" "std::vector< sword::DirEntry > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< sword::DirEntry > * >(argp1);
  {
    try {
      result = (swig::SwigPyIterator *)std_vector_Sl_sword_DirEntry_Sg__iterator(arg1,arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  if (!result) SWIG_fail;
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DirEntryVector___nonzero__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< sword::DirEntry > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_sword__DirEntry_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DirEntryVector___nonzero__" "', argument " "1"" of type '" "std::vector< sword::DirEntry > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< sword::DirEntry > * >(argp1);
  {
    try {
      result = (bool)std_vector_Sl_sword_DirEntry_Sg____nonzero__((std::vector< sword::DirEntry > const *)arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DirEntryVector___bool__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< sword::DirEntry > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_sword__DirEntry_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DirEntryVector___bool__" "', argument " "1"" of type '" "std::vector< sword::DirEntry > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< sword::DirEntry > * >(argp1);
  {
    try {
      result = (bool)std_vector_Sl_sword_DirEntry_Sg____bool__((std::vector< sword::DirEntry > const *)arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DirEntryVector___len__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< sword::DirEntry > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< sword::DirEntry >::size_type result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_sword__DirEntry_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DirEntryVector___len__" "', argument " "1"" of type '" "std::vector< sword::DirEntry > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< sword::DirEntry > * >(argp1);
  {
    try {
      result = std_vector_Sl_sword_DirEntry_Sg____len__((std::vector< sword::DirEntry > const *)arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DirEntryVector___getslice__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< sword::DirEntry > *arg1 = 0 ;
  std::vector< sword::DirEntry >::difference_type arg2 ;
  std::vector< sword::DirEntry >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  std::vector< sword::DirEntry,std::allocator< sword::DirEntry > > *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "DirEntryVector___getslice__", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_sword__DirEntry_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DirEntryVector___getslice__" "', argument " "1"" of type '" "std::vector< sword::DirEntry > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< sword::DirEntry > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DirEntryVector___getslice__" "', argument " "2"" of type '" "std::vector< sword::DirEntry >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< sword::DirEntry >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DirEntryVector___getslice__" "', argument " "3"" of type '" "std::vector< sword::DirEntry >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< sword::DirEntry >::difference_type >(val3);
  {
    try {
      try {
        result = (std::vector< sword::DirEntry,std::allocator< sword::DirEntry > > *)std_vector_Sl_sword_DirEntry_Sg____getslice__(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      } 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_sword__DirEntry_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DirEntryVector___setslice____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< sword::DirEntry > *arg1 = 0 ;
  std::vector< sword::DirEntry >::difference_type arg2 ;
  std::vector< sword::DirEntry >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_sword__DirEntry_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DirEntryVector___setslice__" "', argument " "1"" of type '" "std::vector< sword::DirEntry > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< sword::DirEntry > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DirEntryVector___setslice__" "', argument " "2"" of type '" "std::vector< sword::DirEntry >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< sword::DirEntry >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DirEntryVector___setslice__" "', argument " "3"" of type '" "std::vector< sword::DirEntry >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< sword::DirEntry >::difference_type >(val3);
  {
    try {
      try {
        std_vector_Sl_sword_DirEntry_Sg____setslice____SWIG_0(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      } 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DirEntryVector___setslice____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< sword::DirEntry > *arg1 = 0 ;
  std::vector< sword::DirEntry >::difference_type arg2 ;
  std::vector< sword::DirEntry >::difference_type arg3 ;
  std::vector< sword::DirEntry,std::allocator< sword::DirEntry > > *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_sword__DirEntry_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DirEntryVector___setslice__" "', argument " "1"" of type '" "std::vector< sword::DirEntry > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< sword::DirEntry > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DirEntryVector___setslice__" "', argument " "2"" of type '" "std::vector< sword::DirEntry >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< sword::DirEntry >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DirEntryVector___setslice__" "', argument " "3"" of type '" "std::vector< sword::DirEntry >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< sword::DirEntry >::difference_type >(val3);
  {
    std::vector< sword::DirEntry,std::allocator< sword::DirEntry > > *ptr = (std::vector< sword::DirEntry,std::allocator< sword::DirEntry > > *)0;
    res4 = swig::asptr(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "DirEntryVector___setslice__" "', argument " "4"" of type '" "std::vector< sword::DirEntry,std::allocator< sword::DirEntry > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "DirEntryVector___setslice__" "', argument " "4"" of type '" "std::vector< sword::DirEntry,std::allocator< sword::DirEntry > > const &""'"); 
    }
    arg4 = ptr;
  }
  {
    try {
      try {
        std_vector_Sl_sword_DirEntry_Sg____setslice____SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),(std::vector< sword::DirEntry,std::allocator< sword::DirEntry > > const &)*arg4);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      } 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res4)) delete arg4;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res4)) delete arg4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_DirEntryVector___setslice__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "DirEntryVector___setslice__", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< sword::DirEntry,std::allocator< sword::DirEntry > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_DirEntryVector___setslice____SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< sword::DirEntry,std::allocator< sword::DirEntry > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = swig::asptr(argv[3], (std::vector< sword::DirEntry,std::allocator< sword::DirEntry > >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_DirEntryVector___setslice____SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'DirEntryVector___setslice__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< sword::DirEntry >::__setslice__(std::vector< sword::DirEntry >::difference_type,std::vector< sword::DirEntry >::difference_type)\n"
    "    std::vector< sword::DirEntry >::__setslice__(std::vector< sword::DirEntry >::difference_type,std::vector< sword::DirEntry >::difference_type,std::vector< sword::DirEntry,std::allocator< sword::DirEntry > > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_DirEntryVector___delslice__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< sword::DirEntry > *arg1 = 0 ;
  std::vector< sword::DirEntry >::difference_type arg2 ;
  std::vector< sword::DirEntry >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "DirEntryVector___delslice__", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_sword__DirEntry_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DirEntryVector___delslice__" "', argument " "1"" of type '" "std::vector< sword::DirEntry > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< sword::DirEntry > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DirEntryVector___delslice__" "', argument " "2"" of type '" "std::vector< sword::DirEntry >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< sword::DirEntry >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DirEntryVector___delslice__" "', argument " "3"" of type '" "std::vector< sword::DirEntry >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< sword::DirEntry >::difference_type >(val3);
  {
    try {
      try {
        std_vector_Sl_sword_DirEntry_Sg____delslice__(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      } 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DirEntryVector___delitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< sword::DirEntry > *arg1 = 0 ;
  std::vector< sword::DirEntry >::difference_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_sword__DirEntry_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DirEntryVector___delitem__" "', argument " "1"" of type '" "std::vector< sword::DirEntry > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< sword::DirEntry > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DirEntryVector___delitem__" "', argument " "2"" of type '" "std::vector< sword::DirEntry >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< sword::DirEntry >::difference_type >(val2);
  {
    try {
      try {
        std_vector_Sl_sword_DirEntry_Sg____delitem____SWIG_0(arg1,SWIG_STD_MOVE(arg2));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      } 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DirEntryVector___getitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< sword::DirEntry > *arg1 = 0 ;
  SWIGPY_SLICEOBJECT *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< sword::DirEntry,std::allocator< sword::DirEntry > > *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_sword__DirEntry_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DirEntryVector___getitem__" "', argument " "1"" of type '" "std::vector< sword::DirEntry > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< sword::DirEntry > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "DirEntryVector___getitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    try {
      try {
        result = (std::vector< sword::DirEntry,std::allocator< sword::DirEntry > > *)std_vector_Sl_sword_DirEntry_Sg____getitem____SWIG_0(arg1,arg2);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      } 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_sword__DirEntry_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DirEntryVector___setitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< sword::DirEntry > *arg1 = 0 ;
  SWIGPY_SLICEOBJECT *arg2 = 0 ;
  std::vector< sword::DirEntry,std::allocator< sword::DirEntry > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_sword__DirEntry_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DirEntryVector___setitem__" "', argument " "1"" of type '" "std::vector< sword::DirEntry > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< sword::DirEntry > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "DirEntryVector___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    std::vector< sword::DirEntry,std::allocator< sword::DirEntry > > *ptr = (std::vector< sword::DirEntry,std::allocator< sword::DirEntry > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DirEntryVector___setitem__" "', argument " "3"" of type '" "std::vector< sword::DirEntry,std::allocator< sword::DirEntry > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "DirEntryVector___setitem__" "', argument " "3"" of type '" "std::vector< sword::DirEntry,std::allocator< sword::DirEntry > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      try {
        std_vector_Sl_sword_DirEntry_Sg____setitem____SWIG_0(arg1,arg2,(std::vector< sword::DirEntry,std::allocator< sword::DirEntry > > const &)*arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      } 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_DirEntryVector___setitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< sword::DirEntry > *arg1 = 0 ;
  SWIGPY_SLICEOBJECT *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_sword__DirEntry_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DirEntryVector___setitem__" "', argument " "1"" of type '" "std::vector< sword::DirEntry > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< sword::DirEntry > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "DirEntryVector___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    try {
      try {
        std_vector_Sl_sword_DirEntry_Sg____setitem____SWIG_1(arg1,arg2);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      } 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DirEntryVector___delitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< sword::DirEntry > *arg1 = 0 ;
  SWIGPY_SLICEOBJECT *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_sword__DirEntry_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DirEntryVector___delitem__" "', argument " "1"" of type '" "std::vector< sword::DirEntry > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< sword::DirEntry > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "DirEntryVector___delitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    try {
      try {
        std_vector_Sl_sword_DirEntry_Sg____delitem____SWIG_1(arg1,arg2);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      } 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DirEntryVector___delitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "DirEntryVector___delitem__", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< sword::DirEntry,std::allocator< sword::DirEntry > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        return _wrap_DirEntryVector___delitem____SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< sword::DirEntry,std::allocator< sword::DirEntry > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_DirEntryVector___delitem____SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'DirEntryVector___delitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< sword::DirEntry >::__delitem__(std::vector< sword::DirEntry >::difference_type)\n"
    "    std::vector< sword::DirEntry >::__delitem__(SWIGPY_SLICEOBJECT *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_DirEntryVector___getitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< sword::DirEntry > *arg1 = 0 ;
  std::vector< sword::DirEntry >::difference_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  std::vector< sword::DirEntry >::value_type *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_sword__DirEntry_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DirEntryVector___getitem__" "', argument " "1"" of type '" "std::vector< sword::DirEntry > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< sword::DirEntry > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DirEntryVector___getitem__" "', argument " "2"" of type '" "std::vector< sword::DirEntry >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< sword::DirEntry >::difference_type >(val2);
  {
    try {
      try {
        result = (std::vector< sword::DirEntry >::value_type *) &std_vector_Sl_sword_DirEntry_Sg____getitem____SWIG_1((std::vector< sword::DirEntry > const *)arg1,SWIG_STD_MOVE(arg2));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__DirEntry, 0 |  0 );
  if (!swig::container_owner<swig::traits<std::vector< sword::DirEntry >::value_type>::category>::back_reference(resultobj, swig_obj[0]) && PyErr_Occurred()) {
    SWIG_fail;
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DirEntryVector___getitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "DirEntryVector___getitem__", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< sword::DirEntry,std::allocator< sword::DirEntry > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        return _wrap_DirEntryVector___getitem____SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< sword::DirEntry,std::allocator< sword::DirEntry > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_DirEntryVector___getitem____SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'DirEntryVector___getitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< sword::DirEntry >::__getitem__(SWIGPY_SLICEOBJECT *)\n"
    "    std::vector< sword::DirEntry >::__getitem__(std::vector< sword::DirEntry >::difference_type) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_DirEntryVector___setitem____SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< sword::DirEntry > *arg1 = 0 ;
  std::vector< sword::DirEntry >::difference_type arg2 ;
  std::vector< sword::DirEntry >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_sword__DirEntry_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DirEntryVector___setitem__" "', argument " "1"" of type '" "std::vector< sword::DirEntry > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< sword::DirEntry > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DirEntryVector___setitem__" "', argument " "2"" of type '" "std::vector< sword::DirEntry >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< sword::DirEntry >::difference_type >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_sword__DirEntry,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DirEntryVector___setitem__" "', argument " "3"" of type '" "std::vector< sword::DirEntry >::value_type const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "DirEntryVector___setitem__" "', argument " "3"" of type '" "std::vector< sword::DirEntry >::value_type const &""'"); 
  }
  arg3 = reinterpret_cast< std::vector< sword::DirEntry >::value_type * >(argp3);
  {
    try {
      try {
        std_vector_Sl_sword_DirEntry_Sg____setitem____SWIG_2(arg1,SWIG_STD_MOVE(arg2),(sword::DirEntry const &)*arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DirEntryVector___setitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "DirEntryVector___setitem__", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< sword::DirEntry,std::allocator< sword::DirEntry > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        return _wrap_DirEntryVector___setitem____SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< sword::DirEntry,std::allocator< sword::DirEntry > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< sword::DirEntry,std::allocator< sword::DirEntry > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_DirEntryVector___setitem____SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< sword::DirEntry,std::allocator< sword::DirEntry > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_sword__DirEntry, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_DirEntryVector___setitem____SWIG_2(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'DirEntryVector___setitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< sword::DirEntry >::__setitem__(SWIGPY_SLICEOBJECT *,std::vector< sword::DirEntry,std::allocator< sword::DirEntry > > const &)\n"
    "    std::vector< sword::DirEntry >::__setitem__(SWIGPY_SLICEOBJECT *)\n"
    "    std::vector< sword::DirEntry >::__setitem__(std::vector< sword::DirEntry >::difference_type,std::vector< sword::DirEntry >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_DirEntryVector_pop(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< sword::DirEntry > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< sword::DirEntry >::value_type result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_sword__DirEntry_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DirEntryVector_pop" "', argument " "1"" of type '" "std::vector< sword::DirEntry > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< sword::DirEntry > * >(argp1);
  {
    try {
      try {
        result = std_vector_Sl_sword_DirEntry_Sg__pop(arg1);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj((new std::vector< sword::DirEntry >::value_type(result)), SWIGTYPE_p_sword__DirEntry, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DirEntryVector_append(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< sword::DirEntry > *arg1 = 0 ;
  std::vector< sword::DirEntry >::value_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "DirEntryVector_append", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_sword__DirEntry_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DirEntryVector_append" "', argument " "1"" of type '" "std::vector< sword::DirEntry > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< sword::DirEntry > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_sword__DirEntry,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DirEntryVector_append" "', argument " "2"" of type '" "std::vector< sword::DirEntry >::value_type const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "DirEntryVector_append" "', argument " "2"" of type '" "std::vector< sword::DirEntry >::value_type const &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< sword::DirEntry >::value_type * >(argp2);
  {
    try {
      std_vector_Sl_sword_DirEntry_Sg__append(arg1,(sword::DirEntry const &)*arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DirEntryVector__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  std::vector< sword::DirEntry > *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (std::vector< sword::DirEntry > *)new std::vector< sword::DirEntry >(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_sword__DirEntry_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DirEntryVector__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< sword::DirEntry > *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  std::vector< sword::DirEntry > *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    std::vector< sword::DirEntry,std::allocator< sword::DirEntry > > *ptr = (std::vector< sword::DirEntry,std::allocator< sword::DirEntry > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DirEntryVector" "', argument " "1"" of type '" "std::vector< sword::DirEntry > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_DirEntryVector" "', argument " "1"" of type '" "std::vector< sword::DirEntry > const &""'"); 
    }
    arg1 = ptr;
  }
  {
    try {
      result = (std::vector< sword::DirEntry > *)new std::vector< sword::DirEntry >((std::vector< sword::DirEntry > const &)*arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_sword__DirEntry_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_DirEntryVector_empty(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< sword::DirEntry > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_sword__DirEntry_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DirEntryVector_empty" "', argument " "1"" of type '" "std::vector< sword::DirEntry > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< sword::DirEntry > * >(argp1);
  {
    try {
      result = (bool)((std::vector< sword::DirEntry > const *)arg1)->empty(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DirEntryVector_size(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< sword::DirEntry > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< sword::DirEntry >::size_type result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_sword__DirEntry_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DirEntryVector_size" "', argument " "1"" of type '" "std::vector< sword::DirEntry > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< sword::DirEntry > * >(argp1);
  {
    try {
      result = ((std::vector< sword::DirEntry > const *)arg1)->size(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DirEntryVector_swap(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< sword::DirEntry > *arg1 = 0 ;
  std::vector< sword::DirEntry > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "DirEntryVector_swap", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_sword__DirEntry_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DirEntryVector_swap" "', argument " "1"" of type '" "std::vector< sword::DirEntry > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< sword::DirEntry > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_sword__DirEntry_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DirEntryVector_swap" "', argument " "2"" of type '" "std::vector< sword::DirEntry > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "DirEntryVector_swap" "', argument " "2"" of type '" "std::vector< sword::DirEntry > &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< sword::DirEntry > * >(argp2);
  {
    try {
      (arg1)->swap(*arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DirEntryVector_begin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< sword::DirEntry > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< sword::DirEntry >::iterator result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_sword__DirEntry_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DirEntryVector_begin" "', argument " "1"" of type '" "std::vector< sword::DirEntry > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< sword::DirEntry > * >(argp1);
  {
    try {
      result = (arg1)->begin(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< sword::DirEntry >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DirEntryVector_end(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< sword::DirEntry > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< sword::DirEntry >::iterator result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_sword__DirEntry_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DirEntryVector_end" "', argument " "1"" of type '" "std::vector< sword::DirEntry > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< sword::DirEntry > * >(argp1);
  {
    try {
      result = (arg1)->end(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< sword::DirEntry >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DirEntryVector_rbegin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< sword::DirEntry > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< sword::DirEntry >::reverse_iterator result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_sword__DirEntry_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DirEntryVector_rbegin" "', argument " "1"" of type '" "std::vector< sword::DirEntry > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< sword::DirEntry > * >(argp1);
  {
    try {
      result = (arg1)->rbegin(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< sword::DirEntry >::reverse_iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DirEntryVector_rend(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< sword::DirEntry > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< sword::DirEntry >::reverse_iterator result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_sword__DirEntry_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DirEntryVector_rend" "', argument " "1"" of type '" "std::vector< sword::DirEntry > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< sword::DirEntry > * >(argp1);
  {
    try {
      result = (arg1)->rend(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< sword::DirEntry >::reverse_iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DirEntryVector_clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< sword::DirEntry > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_sword__DirEntry_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DirEntryVector_clear" "', argument " "1"" of type '" "std::vector< sword::DirEntry > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< sword::DirEntry > * >(argp1);
  {
    try {
      (arg1)->clear(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DirEntryVector_get_allocator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< sword::DirEntry > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< std::allocator< sword::DirEntry > > result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_sword__DirEntry_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DirEntryVector_get_allocator" "', argument " "1"" of type '" "std::vector< sword::DirEntry > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< sword::DirEntry > * >(argp1);
  {
    try {
      result = ((std::vector< sword::DirEntry > const *)arg1)->get_allocator(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj((new std::vector< sword::DirEntry >::allocator_type(result)), SWIGTYPE_p_std__allocatorT_sword__DirEntry_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DirEntryVector__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< sword::DirEntry >::size_type arg1 ;
  size_t val1 ;
  int ecode1 = 0 ;
  std::vector< sword::DirEntry > *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DirEntryVector" "', argument " "1"" of type '" "std::vector< sword::DirEntry >::size_type""'");
  } 
  arg1 = static_cast< std::vector< sword::DirEntry >::size_type >(val1);
  {
    try {
      result = (std::vector< sword::DirEntry > *)new std::vector< sword::DirEntry >(SWIG_STD_MOVE(arg1)); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_sword__DirEntry_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DirEntryVector_pop_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< sword::DirEntry > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_sword__DirEntry_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DirEntryVector_pop_back" "', argument " "1"" of type '" "std::vector< sword::DirEntry > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< sword::DirEntry > * >(argp1);
  {
    try {
      (arg1)->pop_back(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DirEntryVector_resize__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< sword::DirEntry > *arg1 = 0 ;
  std::vector< sword::DirEntry >::size_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_sword__DirEntry_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DirEntryVector_resize" "', argument " "1"" of type '" "std::vector< sword::DirEntry > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< sword::DirEntry > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DirEntryVector_resize" "', argument " "2"" of type '" "std::vector< sword::DirEntry >::size_type""'");
  } 
  arg2 = static_cast< std::vector< sword::DirEntry >::size_type >(val2);
  {
    try {
      (arg1)->resize(SWIG_STD_MOVE(arg2)); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DirEntryVector_erase__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< sword::DirEntry > *arg1 = 0 ;
  std::vector< sword::DirEntry >::iterator arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  std::vector< sword::DirEntry >::iterator result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_sword__DirEntry_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DirEntryVector_erase" "', argument " "1"" of type '" "std::vector< sword::DirEntry > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< sword::DirEntry > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "DirEntryVector_erase" "', argument " "2"" of type '" "std::vector< sword::DirEntry >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< sword::DirEntry >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< sword::DirEntry >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "DirEntryVector_erase" "', argument " "2"" of type '" "std::vector< sword::DirEntry >::iterator""'");
    }
  }
  {
    try {
      result = std_vector_Sl_sword_DirEntry_Sg__erase__SWIG_0(arg1,SWIG_STD_MOVE(arg2)); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< sword::DirEntry >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DirEntryVector_erase__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< sword::DirEntry > *arg1 = 0 ;
  std::vector< sword::DirEntry >::iterator arg2 ;
  std::vector< sword::DirEntry >::iterator arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  swig::SwigPyIterator *iter3 = 0 ;
  int res3 ;
  std::vector< sword::DirEntry >::iterator result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_sword__DirEntry_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DirEntryVector_erase" "', argument " "1"" of type '" "std::vector< sword::DirEntry > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< sword::DirEntry > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "DirEntryVector_erase" "', argument " "2"" of type '" "std::vector< sword::DirEntry >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< sword::DirEntry >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< sword::DirEntry >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "DirEntryVector_erase" "', argument " "2"" of type '" "std::vector< sword::DirEntry >::iterator""'");
    }
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], SWIG_as_voidptrptr(&iter3), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res3) || !iter3) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "DirEntryVector_erase" "', argument " "3"" of type '" "std::vector< sword::DirEntry >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< sword::DirEntry >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< sword::DirEntry >::iterator > *>(iter3);
    if (iter_t) {
      arg3 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "DirEntryVector_erase" "', argument " "3"" of type '" "std::vector< sword::DirEntry >::iterator""'");
    }
  }
  {
    try {
      result = std_vector_Sl_sword_DirEntry_Sg__erase__SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3)); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< sword::DirEntry >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DirEntryVector_erase(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "DirEntryVector_erase", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< sword::DirEntry,std::allocator< sword::DirEntry > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< sword::DirEntry >::iterator > *>(iter) != 0));
      if (_v) {
        return _wrap_DirEntryVector_erase__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< sword::DirEntry,std::allocator< sword::DirEntry > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< sword::DirEntry >::iterator > *>(iter) != 0));
      if (_v) {
        swig::SwigPyIterator *iter = 0;
        int res = SWIG_ConvertPtr(argv[2], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
        _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< sword::DirEntry >::iterator > *>(iter) != 0));
        if (_v) {
          return _wrap_DirEntryVector_erase__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'DirEntryVector_erase'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< sword::DirEntry >::erase(std::vector< sword::DirEntry >::iterator)\n"
    "    std::vector< sword::DirEntry >::erase(std::vector< sword::DirEntry >::iterator,std::vector< sword::DirEntry >::iterator)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_new_DirEntryVector__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< sword::DirEntry >::size_type arg1 ;
  std::vector< sword::DirEntry >::value_type *arg2 = 0 ;
  size_t val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  std::vector< sword::DirEntry > *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DirEntryVector" "', argument " "1"" of type '" "std::vector< sword::DirEntry >::size_type""'");
  } 
  arg1 = static_cast< std::vector< sword::DirEntry >::size_type >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_sword__DirEntry,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_DirEntryVector" "', argument " "2"" of type '" "std::vector< sword::DirEntry >::value_type const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_DirEntryVector" "', argument " "2"" of type '" "std::vector< sword::DirEntry >::value_type const &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< sword::DirEntry >::value_type * >(argp2);
  {
    try {
      result = (std::vector< sword::DirEntry > *)new std::vector< sword::DirEntry >(SWIG_STD_MOVE(arg1),(std::vector< sword::DirEntry >::value_type const &)*arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_sword__DirEntry_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DirEntryVector(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_DirEntryVector", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_DirEntryVector__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_DirEntryVector__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< sword::DirEntry,std::allocator< sword::DirEntry > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DirEntryVector__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_sword__DirEntry, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_DirEntryVector__SWIG_3(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_DirEntryVector'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< sword::DirEntry >::vector()\n"
    "    std::vector< sword::DirEntry >::vector(std::vector< sword::DirEntry > const &)\n"
    "    std::vector< sword::DirEntry >::vector(std::vector< sword::DirEntry >::size_type)\n"
    "    std::vector< sword::DirEntry >::vector(std::vector< sword::DirEntry >::size_type,std::vector< sword::DirEntry >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_DirEntryVector_push_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< sword::DirEntry > *arg1 = 0 ;
  std::vector< sword::DirEntry >::value_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "DirEntryVector_push_back", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_sword__DirEntry_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DirEntryVector_push_back" "', argument " "1"" of type '" "std::vector< sword::DirEntry > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< sword::DirEntry > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_sword__DirEntry,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DirEntryVector_push_back" "', argument " "2"" of type '" "std::vector< sword::DirEntry >::value_type const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "DirEntryVector_push_back" "', argument " "2"" of type '" "std::vector< sword::DirEntry >::value_type const &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< sword::DirEntry >::value_type * >(argp2);
  {
    try {
      (arg1)->push_back((std::vector< sword::DirEntry >::value_type const &)*arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DirEntryVector_front(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< sword::DirEntry > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< sword::DirEntry >::value_type *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_sword__DirEntry_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DirEntryVector_front" "', argument " "1"" of type '" "std::vector< sword::DirEntry > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< sword::DirEntry > * >(argp1);
  {
    try {
      result = (std::vector< sword::DirEntry >::value_type *) &((std::vector< sword::DirEntry > const *)arg1)->front(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__DirEntry, 0 |  0 );
  if (!swig::container_owner<swig::traits<std::vector< sword::DirEntry >::value_type>::category>::back_reference(resultobj, swig_obj[0]) && PyErr_Occurred()) {
    SWIG_fail;
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DirEntryVector_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< sword::DirEntry > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< sword::DirEntry >::value_type *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_sword__DirEntry_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DirEntryVector_back" "', argument " "1"" of type '" "std::vector< sword::DirEntry > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< sword::DirEntry > * >(argp1);
  {
    try {
      result = (std::vector< sword::DirEntry >::value_type *) &((std::vector< sword::DirEntry > const *)arg1)->back(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__DirEntry, 0 |  0 );
  if (!swig::container_owner<swig::traits<std::vector< sword::DirEntry >::value_type>::category>::back_reference(resultobj, swig_obj[0]) && PyErr_Occurred()) {
    SWIG_fail;
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DirEntryVector_assign(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< sword::DirEntry > *arg1 = 0 ;
  std::vector< sword::DirEntry >::size_type arg2 ;
  std::vector< sword::DirEntry >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "DirEntryVector_assign", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_sword__DirEntry_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DirEntryVector_assign" "', argument " "1"" of type '" "std::vector< sword::DirEntry > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< sword::DirEntry > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DirEntryVector_assign" "', argument " "2"" of type '" "std::vector< sword::DirEntry >::size_type""'");
  } 
  arg2 = static_cast< std::vector< sword::DirEntry >::size_type >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_sword__DirEntry,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DirEntryVector_assign" "', argument " "3"" of type '" "std::vector< sword::DirEntry >::value_type const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "DirEntryVector_assign" "', argument " "3"" of type '" "std::vector< sword::DirEntry >::value_type const &""'"); 
  }
  arg3 = reinterpret_cast< std::vector< sword::DirEntry >::value_type * >(argp3);
  {
    try {
      (arg1)->assign(SWIG_STD_MOVE(arg2),(std::vector< sword::DirEntry >::value_type const &)*arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DirEntryVector_resize__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< sword::DirEntry > *arg1 = 0 ;
  std::vector< sword::DirEntry >::size_type arg2 ;
  std::vector< sword::DirEntry >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_sword__DirEntry_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DirEntryVector_resize" "', argument " "1"" of type '" "std::vector< sword::DirEntry > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< sword::DirEntry > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DirEntryVector_resize" "', argument " "2"" of type '" "std::vector< sword::DirEntry >::size_type""'");
  } 
  arg2 = static_cast< std::vector< sword::DirEntry >::size_type >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_sword__DirEntry,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DirEntryVector_resize" "', argument " "3"" of type '" "std::vector< sword::DirEntry >::value_type const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "DirEntryVector_resize" "', argument " "3"" of type '" "std::vector< sword::DirEntry >::value_type const &""'"); 
  }
  arg3 = reinterpret_cast< std::vector< sword::DirEntry >::value_type * >(argp3);
  {
    try {
      (arg1)->resize(SWIG_STD_MOVE(arg2),(std::vector< sword::DirEntry >::value_type const &)*arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DirEntryVector_resize(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "DirEntryVector_resize", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< sword::DirEntry,std::allocator< sword::DirEntry > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_DirEntryVector_resize__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< sword::DirEntry,std::allocator< sword::DirEntry > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_sword__DirEntry, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_DirEntryVector_resize__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'DirEntryVector_resize'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< sword::DirEntry >::resize(std::vector< sword::DirEntry >::size_type)\n"
    "    std::vector< sword::DirEntry >::resize(std::vector< sword::DirEntry >::size_type,std::vector< sword::DirEntry >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_DirEntryVector_insert__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< sword::DirEntry > *arg1 = 0 ;
  std::vector< sword::DirEntry >::iterator arg2 ;
  std::vector< sword::DirEntry >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  std::vector< sword::DirEntry >::iterator result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_sword__DirEntry_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DirEntryVector_insert" "', argument " "1"" of type '" "std::vector< sword::DirEntry > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< sword::DirEntry > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "DirEntryVector_insert" "', argument " "2"" of type '" "std::vector< sword::DirEntry >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< sword::DirEntry >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< sword::DirEntry >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "DirEntryVector_insert" "', argument " "2"" of type '" "std::vector< sword::DirEntry >::iterator""'");
    }
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_sword__DirEntry,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DirEntryVector_insert" "', argument " "3"" of type '" "std::vector< sword::DirEntry >::value_type const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "DirEntryVector_insert" "', argument " "3"" of type '" "std::vector< sword::DirEntry >::value_type const &""'"); 
  }
  arg3 = reinterpret_cast< std::vector< sword::DirEntry >::value_type * >(argp3);
  {
    try {
      result = std_vector_Sl_sword_DirEntry_Sg__insert__SWIG_0(arg1,SWIG_STD_MOVE(arg2),(sword::DirEntry const &)*arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< sword::DirEntry >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DirEntryVector_insert__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< sword::DirEntry > *arg1 = 0 ;
  std::vector< sword::DirEntry >::iterator arg2 ;
  std::vector< sword::DirEntry >::size_type arg3 ;
  std::vector< sword::DirEntry >::value_type *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  size_t val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_sword__DirEntry_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DirEntryVector_insert" "', argument " "1"" of type '" "std::vector< sword::DirEntry > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< sword::DirEntry > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "DirEntryVector_insert" "', argument " "2"" of type '" "std::vector< sword::DirEntry >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< sword::DirEntry >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< sword::DirEntry >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "DirEntryVector_insert" "', argument " "2"" of type '" "std::vector< sword::DirEntry >::iterator""'");
    }
  }
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DirEntryVector_insert" "', argument " "3"" of type '" "std::vector< sword::DirEntry >::size_type""'");
  } 
  arg3 = static_cast< std::vector< sword::DirEntry >::size_type >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_sword__DirEntry,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "DirEntryVector_insert" "', argument " "4"" of type '" "std::vector< sword::DirEntry >::value_type const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "DirEntryVector_insert" "', argument " "4"" of type '" "std::vector< sword::DirEntry >::value_type const &""'"); 
  }
  arg4 = reinterpret_cast< std::vector< sword::DirEntry >::value_type * >(argp4);
  {
    try {
      std_vector_Sl_sword_DirEntry_Sg__insert__SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),(sword::DirEntry const &)*arg4); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DirEntryVector_insert(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "DirEntryVector_insert", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< sword::DirEntry,std::allocator< sword::DirEntry > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< sword::DirEntry >::iterator > *>(iter) != 0));
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_sword__DirEntry, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_DirEntryVector_insert__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< sword::DirEntry,std::allocator< sword::DirEntry > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< sword::DirEntry >::iterator > *>(iter) != 0));
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_sword__DirEntry, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_DirEntryVector_insert__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'DirEntryVector_insert'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< sword::DirEntry >::insert(std::vector< sword::DirEntry >::iterator,std::vector< sword::DirEntry >::value_type const &)\n"
    "    std::vector< sword::DirEntry >::insert(std::vector< sword::DirEntry >::iterator,std::vector< sword::DirEntry >::size_type,std::vector< sword::DirEntry >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_DirEntryVector_reserve(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< sword::DirEntry > *arg1 = 0 ;
  std::vector< sword::DirEntry >::size_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "DirEntryVector_reserve", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_sword__DirEntry_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DirEntryVector_reserve" "', argument " "1"" of type '" "std::vector< sword::DirEntry > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< sword::DirEntry > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DirEntryVector_reserve" "', argument " "2"" of type '" "std::vector< sword::DirEntry >::size_type""'");
  } 
  arg2 = static_cast< std::vector< sword::DirEntry >::size_type >(val2);
  {
    try {
      (arg1)->reserve(SWIG_STD_MOVE(arg2)); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DirEntryVector_capacity(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< sword::DirEntry > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< sword::DirEntry >::size_type result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_sword__DirEntry_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DirEntryVector_capacity" "', argument " "1"" of type '" "std::vector< sword::DirEntry > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< sword::DirEntry > * >(argp1);
  {
    try {
      result = ((std::vector< sword::DirEntry > const *)arg1)->capacity(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_DirEntryVector(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< sword::DirEntry > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_sword__DirEntry_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DirEntryVector" "', argument " "1"" of type '" "std::vector< sword::DirEntry > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< sword::DirEntry > * >(argp1);
  {
    try {
      delete arg1; 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *DirEntryVector_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__vectorT_sword__DirEntry_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *DirEntryVector_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SWClass_isAssignableFrom(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWClass *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SWClass_isAssignableFrom", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWClass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWClass_isAssignableFrom" "', argument " "1"" of type '" "sword::SWClass const *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWClass * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SWClass_isAssignableFrom" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    try {
      result = (bool)((sword::SWClass const *)arg1)->isAssignableFrom((char const *)arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SWClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWClass *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWClass, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SWClass" "', argument " "1"" of type '" "sword::SWClass *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWClass * >(argp1);
  {
    try {
      delete arg1; 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SWClass_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_sword__SWClass, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_SWObject(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWClass *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  sword::SWObject *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_sword__SWClass,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SWObject" "', argument " "1"" of type '" "sword::SWClass const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SWObject" "', argument " "1"" of type '" "sword::SWClass const &""'"); 
  }
  arg1 = reinterpret_cast< sword::SWClass * >(argp1);
  {
    try {
      result = (sword::SWObject *)new sword::SWObject((sword::SWClass const &)*arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__SWObject, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWObject_getClass(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWObject *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  sword::SWClass *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWObject_getClass" "', argument " "1"" of type '" "sword::SWObject const *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWObject * >(argp1);
  {
    try {
      result = (sword::SWClass *)((sword::SWObject const *)arg1)->getClass(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__SWClass, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SWObject(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWObject *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWObject, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SWObject" "', argument " "1"" of type '" "sword::SWObject *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWObject * >(argp1);
  {
    try {
      delete arg1; 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SWObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_sword__SWObject, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SWObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SWConfig__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  sword::SWConfig *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SWConfig" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  {
    try {
      result = (sword::SWConfig *)new sword::SWConfig((char const *)arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__SWConfig, SWIG_POINTER_NEW |  0 );
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SWConfig__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  sword::SWConfig *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (sword::SWConfig *)new sword::SWConfig(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__SWConfig, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SWConfig(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SWConfig", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_SWConfig__SWIG_1(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SWConfig__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SWConfig'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    sword::SWConfig::SWConfig(char const *)\n"
    "    sword::SWConfig::SWConfig()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SWConfig(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWConfig *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWConfig, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SWConfig" "', argument " "1"" of type '" "sword::SWConfig *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWConfig * >(argp1);
  {
    try {
      delete arg1; 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWConfig_getSections(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWConfig *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  sword::SectionMap *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWConfig, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWConfig_getSections" "', argument " "1"" of type '" "sword::SWConfig const *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWConfig * >(argp1);
  {
    try {
      result = (sword::SectionMap *) &((sword::SWConfig const *)arg1)->getSections(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__mapT_sword__SWBuf_sword__multimapwithdefaultT_sword__SWBuf_sword__SWBuf_std__lessT_sword__SWBuf_t_t_std__lessT_sword__SWBuf_t_std__allocatorT_std__pairT_sword__SWBuf_const_sword__multimapwithdefaultT_sword__SWBuf_sword__SWBuf_std__lessT_sword__SWBuf_t_t_t_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWConfig_load(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWConfig *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWConfig, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWConfig_load" "', argument " "1"" of type '" "sword::SWConfig *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWConfig * >(argp1);
  {
    try {
      (arg1)->load(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWConfig_save(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWConfig *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWConfig, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWConfig_save" "', argument " "1"" of type '" "sword::SWConfig const *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWConfig * >(argp1);
  {
    try {
      ((sword::SWConfig const *)arg1)->save(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWConfig_augment(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWConfig *arg1 = 0 ;
  sword::SWConfig *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SWConfig_augment", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWConfig, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWConfig_augment" "', argument " "1"" of type '" "sword::SWConfig *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWConfig * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_sword__SWConfig,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SWConfig_augment" "', argument " "2"" of type '" "sword::SWConfig const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SWConfig_augment" "', argument " "2"" of type '" "sword::SWConfig const &""'"); 
  }
  arg2 = reinterpret_cast< sword::SWConfig * >(argp2);
  {
    try {
      (arg1)->augment((sword::SWConfig const &)*arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWConfig_getSection(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWConfig *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  sword::ConfigEntMap *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SWConfig_getSection", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWConfig, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWConfig_getSection" "', argument " "1"" of type '" "sword::SWConfig *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWConfig * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SWConfig_getSection" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    try {
      result = (sword::ConfigEntMap *) &(arg1)->getSection((char const *)arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__multimapwithdefaultT_sword__SWBuf_sword__SWBuf_std__lessT_sword__SWBuf_t_t, 0 |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWConfig_getValue(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWConfig *arg1 = 0 ;
  char *arg2 = 0 ;
  char *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  PyObject *swig_obj[3] ;
  sword::SWBuf result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SWConfig_getValue", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWConfig, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWConfig_getValue" "', argument " "1"" of type '" "sword::SWConfig *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWConfig * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SWConfig_getValue" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SWConfig_getValue" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  {
    try {
      result = (arg1)->getValue((char const *)arg2,(char const *)arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj((new sword::SWBuf(result)), SWIGTYPE_p_sword__SWBuf, SWIG_POINTER_OWN |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWConfig_setValue(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWConfig *arg1 = 0 ;
  char *arg2 = 0 ;
  char *arg3 = 0 ;
  char *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  int res4 ;
  char *buf4 = 0 ;
  int alloc4 = 0 ;
  PyObject *swig_obj[4] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SWConfig_setValue", 4, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWConfig, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWConfig_setValue" "', argument " "1"" of type '" "sword::SWConfig *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWConfig * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SWConfig_setValue" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SWConfig_setValue" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  res4 = SWIG_AsCharPtrAndSize(swig_obj[3], &buf4, NULL, &alloc4);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SWConfig_setValue" "', argument " "4"" of type '" "char const *""'");
  }
  arg4 = reinterpret_cast< char * >(buf4);
  {
    try {
      (arg1)->setValue((char const *)arg2,(char const *)arg3,(char const *)arg4); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWConfig_getFileName(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWConfig *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  sword::SWBuf result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWConfig, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWConfig_getFileName" "', argument " "1"" of type '" "sword::SWConfig const *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWConfig * >(argp1);
  {
    try {
      result = ((sword::SWConfig const *)arg1)->getFileName(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj((new sword::SWBuf(result)), SWIGTYPE_p_sword__SWBuf, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWConfig_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWConfig *arg1 = 0 ;
  char *arg2 = 0 ;
  char *arg3 = 0 ;
  char *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  int res4 ;
  char *buf4 = 0 ;
  int alloc4 = 0 ;
  PyObject *swig_obj[4] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SWConfig_set", 4, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWConfig, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWConfig_set" "', argument " "1"" of type '" "sword::SWConfig *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWConfig * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SWConfig_set" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SWConfig_set" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  res4 = SWIG_AsCharPtrAndSize(swig_obj[3], &buf4, NULL, &alloc4);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SWConfig_set" "', argument " "4"" of type '" "char const *""'");
  }
  arg4 = reinterpret_cast< char * >(buf4);
  {
    try {
      sword_SWConfig_set(arg1,(char const *)arg2,(char const *)arg3,(char const *)arg4); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWConfig_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWConfig *arg1 = 0 ;
  char *arg2 = 0 ;
  char *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  PyObject *swig_obj[3] ;
  char *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SWConfig_get", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWConfig, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWConfig_get" "', argument " "1"" of type '" "sword::SWConfig *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWConfig * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SWConfig_get" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SWConfig_get" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  {
    try {
      result = (char *)sword_SWConfig_get(arg1,(char const *)arg2,(char const *)arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return NULL;
}


SWIGINTERN PyObject *SWConfig_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_sword__SWConfig, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SWConfig_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SWVersion_major_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWVersion *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SWVersion_major_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWVersion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWVersion_major_set" "', argument " "1"" of type '" "sword::SWVersion *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWVersion * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SWVersion_major_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  if (arg1) (arg1)->major = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWVersion_major_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWVersion *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWVersion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWVersion_major_get" "', argument " "1"" of type '" "sword::SWVersion *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWVersion * >(argp1);
  result = (int) ((arg1)->major);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWVersion_minor_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWVersion *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SWVersion_minor_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWVersion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWVersion_minor_set" "', argument " "1"" of type '" "sword::SWVersion *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWVersion * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SWVersion_minor_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  if (arg1) (arg1)->minor = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWVersion_minor_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWVersion *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWVersion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWVersion_minor_get" "', argument " "1"" of type '" "sword::SWVersion *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWVersion * >(argp1);
  result = (int) ((arg1)->minor);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWVersion_minor2_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWVersion *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SWVersion_minor2_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWVersion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWVersion_minor2_set" "', argument " "1"" of type '" "sword::SWVersion *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWVersion * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SWVersion_minor2_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  if (arg1) (arg1)->minor2 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWVersion_minor2_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWVersion *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWVersion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWVersion_minor2_get" "', argument " "1"" of type '" "sword::SWVersion *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWVersion * >(argp1);
  result = (int) ((arg1)->minor2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWVersion_minor3_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWVersion *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SWVersion_minor3_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWVersion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWVersion_minor3_set" "', argument " "1"" of type '" "sword::SWVersion *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWVersion * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SWVersion_minor3_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  if (arg1) (arg1)->minor3 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWVersion_minor3_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWVersion *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWVersion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWVersion_minor3_get" "', argument " "1"" of type '" "sword::SWVersion *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWVersion * >(argp1);
  result = (int) ((arg1)->minor3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SWVersion__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  sword::SWVersion *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SWVersion" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  {
    try {
      result = (sword::SWVersion *)new sword::SWVersion((char const *)arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__SWVersion, SWIG_POINTER_NEW |  0 );
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SWVersion__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  sword::SWVersion *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (sword::SWVersion *)new sword::SWVersion(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__SWVersion, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SWVersion(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SWVersion", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_SWVersion__SWIG_1(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SWVersion__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SWVersion'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    sword::SWVersion::SWVersion(char const *)\n"
    "    sword::SWVersion::SWVersion()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SWVersion_compare(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWVersion *arg1 = 0 ;
  sword::SWVersion *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SWVersion_compare", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWVersion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWVersion_compare" "', argument " "1"" of type '" "sword::SWVersion const *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWVersion * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_sword__SWVersion,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SWVersion_compare" "', argument " "2"" of type '" "sword::SWVersion const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SWVersion_compare" "', argument " "2"" of type '" "sword::SWVersion const &""'"); 
  }
  arg2 = reinterpret_cast< sword::SWVersion * >(argp2);
  {
    try {
      result = (int)((sword::SWVersion const *)arg1)->compare((sword::SWVersion const &)*arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWVersion_getText(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWVersion *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWVersion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWVersion_getText" "', argument " "1"" of type '" "sword::SWVersion const *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWVersion * >(argp1);
  {
    try {
      result = (char *)((sword::SWVersion const *)arg1)->getText(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWVersion___gt__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWVersion *arg1 = 0 ;
  sword::SWVersion *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SWVersion___gt__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWVersion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWVersion___gt__" "', argument " "1"" of type '" "sword::SWVersion const *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWVersion * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_sword__SWVersion,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SWVersion___gt__" "', argument " "2"" of type '" "sword::SWVersion const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SWVersion___gt__" "', argument " "2"" of type '" "sword::SWVersion const &""'"); 
  }
  arg2 = reinterpret_cast< sword::SWVersion * >(argp2);
  {
    try {
      result = (bool)((sword::SWVersion const *)arg1)->operator >((sword::SWVersion const &)*arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SWVersion___lt__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWVersion *arg1 = 0 ;
  sword::SWVersion *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SWVersion___lt__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWVersion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWVersion___lt__" "', argument " "1"" of type '" "sword::SWVersion const *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWVersion * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_sword__SWVersion,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SWVersion___lt__" "', argument " "2"" of type '" "sword::SWVersion const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SWVersion___lt__" "', argument " "2"" of type '" "sword::SWVersion const &""'"); 
  }
  arg2 = reinterpret_cast< sword::SWVersion * >(argp2);
  {
    try {
      result = (bool)((sword::SWVersion const *)arg1)->operator <((sword::SWVersion const &)*arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SWVersion___ge__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWVersion *arg1 = 0 ;
  sword::SWVersion *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SWVersion___ge__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWVersion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWVersion___ge__" "', argument " "1"" of type '" "sword::SWVersion const *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWVersion * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_sword__SWVersion,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SWVersion___ge__" "', argument " "2"" of type '" "sword::SWVersion const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SWVersion___ge__" "', argument " "2"" of type '" "sword::SWVersion const &""'"); 
  }
  arg2 = reinterpret_cast< sword::SWVersion * >(argp2);
  {
    try {
      result = (bool)((sword::SWVersion const *)arg1)->operator >=((sword::SWVersion const &)*arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SWVersion___le__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWVersion *arg1 = 0 ;
  sword::SWVersion *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SWVersion___le__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWVersion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWVersion___le__" "', argument " "1"" of type '" "sword::SWVersion const *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWVersion * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_sword__SWVersion,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SWVersion___le__" "', argument " "2"" of type '" "sword::SWVersion const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SWVersion___le__" "', argument " "2"" of type '" "sword::SWVersion const &""'"); 
  }
  arg2 = reinterpret_cast< sword::SWVersion * >(argp2);
  {
    try {
      result = (bool)((sword::SWVersion const *)arg1)->operator <=((sword::SWVersion const &)*arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SWVersion___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWVersion *arg1 = 0 ;
  sword::SWVersion *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SWVersion___eq__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWVersion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWVersion___eq__" "', argument " "1"" of type '" "sword::SWVersion const *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWVersion * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_sword__SWVersion,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SWVersion___eq__" "', argument " "2"" of type '" "sword::SWVersion const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SWVersion___eq__" "', argument " "2"" of type '" "sword::SWVersion const &""'"); 
  }
  arg2 = reinterpret_cast< sword::SWVersion * >(argp2);
  {
    try {
      result = (bool)((sword::SWVersion const *)arg1)->operator ==((sword::SWVersion const &)*arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN int Swig_var_SWVersion_currentVersion_set(PyObject *_val) {
  {
    void *argp = 0;
    int res = SWIG_ConvertPtr(_val, &argp, SWIGTYPE_p_sword__SWVersion,  0  | 0);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in variable '""sword::SWVersion::currentVersion""' of type '""sword::SWVersion""'");
    }
    if (!argp) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in variable '""sword::SWVersion::currentVersion""' of type '""sword::SWVersion""'");
    } else {
      sword::SWVersion * temp;
      temp  = reinterpret_cast< sword::SWVersion * >(argp);
      sword::SWVersion::currentVersion = *temp;
      if (SWIG_IsNewObj(res)) delete temp;
    }
  }
  return 0;
fail:
  return 1;
}


SWIGINTERN PyObject *Swig_var_SWVersion_currentVersion_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&sword::SWVersion::currentVersion), SWIGTYPE_p_sword__SWVersion,  0 );
  return pyobj;
}


SWIGINTERN PyObject *_wrap_SWVersion_currentVersion_get(PyObject *SWIGUNUSEDPARM(self), PyObject *SWIGUNUSEDPARM(args)) {
  return Swig_var_SWVersion_currentVersion_get();
}


SWIGINTERN PyObject *_wrap_SWVersion_currentVersion_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  int res;
  
  res = Swig_var_SWVersion_currentVersion_set(args);
  return !res ? SWIG_Py_Void() : NULL;
}


SWIGINTERN PyObject *_wrap_delete_SWVersion(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWVersion *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWVersion, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SWVersion" "', argument " "1"" of type '" "sword::SWVersion *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWVersion * >(argp1);
  {
    try {
      delete arg1; 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SWVersion_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_sword__SWVersion, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SWVersion_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN int Swig_var_RawVerse_nl_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RawVerse_nl is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RawVerse_nl_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(sword::RawVerse::nl));
  return pyobj;
}


SWIGINTERN PyObject *_wrap_new_RawVerse__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  int arg2 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  sword::RawVerse *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_RawVerse" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_RawVerse" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    try {
      result = (sword::RawVerse *)new sword::RawVerse((char const *)arg1,arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__RawVerse, SWIG_POINTER_NEW |  0 );
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RawVerse__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  sword::RawVerse *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_RawVerse" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  {
    try {
      result = (sword::RawVerse *)new sword::RawVerse((char const *)arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__RawVerse, SWIG_POINTER_NEW |  0 );
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RawVerse(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_RawVerse", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_RawVerse__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_RawVerse__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_RawVerse'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    sword::RawVerse::RawVerse(char const *,int)\n"
    "    sword::RawVerse::RawVerse(char const *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_RawVerse(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::RawVerse *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__RawVerse, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RawVerse" "', argument " "1"" of type '" "sword::RawVerse *""'"); 
  }
  arg1 = reinterpret_cast< sword::RawVerse * >(argp1);
  {
    try {
      delete arg1; 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RawVerse_findOffset(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::RawVerse *arg1 = 0 ;
  char arg2 ;
  long arg3 ;
  long *arg4 = 0 ;
  unsigned short *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char val2 ;
  int ecode2 = 0 ;
  long val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  PyObject *swig_obj[5] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "RawVerse_findOffset", 5, 5, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__RawVerse, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RawVerse_findOffset" "', argument " "1"" of type '" "sword::RawVerse const *""'"); 
  }
  arg1 = reinterpret_cast< sword::RawVerse * >(argp1);
  ecode2 = SWIG_AsVal_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RawVerse_findOffset" "', argument " "2"" of type '" "char""'");
  } 
  arg2 = static_cast< char >(val2);
  ecode3 = SWIG_AsVal_long(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RawVerse_findOffset" "', argument " "3"" of type '" "long""'");
  } 
  arg3 = static_cast< long >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_long, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "RawVerse_findOffset" "', argument " "4"" of type '" "long *""'"); 
  }
  arg4 = reinterpret_cast< long * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5,SWIGTYPE_p_unsigned_short, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "RawVerse_findOffset" "', argument " "5"" of type '" "unsigned short *""'"); 
  }
  arg5 = reinterpret_cast< unsigned short * >(argp5);
  {
    try {
      ((sword::RawVerse const *)arg1)->findOffset(arg2,arg3,arg4,arg5); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RawVerse_readText(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::RawVerse *arg1 = 0 ;
  char arg2 ;
  long arg3 ;
  unsigned short arg4 ;
  sword::SWBuf *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char val2 ;
  int ecode2 = 0 ;
  long val3 ;
  int ecode3 = 0 ;
  unsigned short val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  PyObject *swig_obj[5] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "RawVerse_readText", 5, 5, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__RawVerse, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RawVerse_readText" "', argument " "1"" of type '" "sword::RawVerse const *""'"); 
  }
  arg1 = reinterpret_cast< sword::RawVerse * >(argp1);
  ecode2 = SWIG_AsVal_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RawVerse_readText" "', argument " "2"" of type '" "char""'");
  } 
  arg2 = static_cast< char >(val2);
  ecode3 = SWIG_AsVal_long(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RawVerse_readText" "', argument " "3"" of type '" "long""'");
  } 
  arg3 = static_cast< long >(val3);
  ecode4 = SWIG_AsVal_unsigned_SS_short(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "RawVerse_readText" "', argument " "4"" of type '" "unsigned short""'");
  } 
  arg4 = static_cast< unsigned short >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_sword__SWBuf,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "RawVerse_readText" "', argument " "5"" of type '" "sword::SWBuf &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "RawVerse_readText" "', argument " "5"" of type '" "sword::SWBuf &""'"); 
  }
  arg5 = reinterpret_cast< sword::SWBuf * >(argp5);
  {
    try {
      ((sword::RawVerse const *)arg1)->readText(arg2,arg3,arg4,*arg5); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RawVerse_createModule__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  char *arg2 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  char result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RawVerse_createModule" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RawVerse_createModule" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    try {
      result = (char)sword::RawVerse::createModule((char const *)arg1,(char const *)arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_char(static_cast< char >(result));
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_RawVerse_createModule__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  char result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RawVerse_createModule" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  {
    try {
      result = (char)sword::RawVerse::createModule((char const *)arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_char(static_cast< char >(result));
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_RawVerse_createModule(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "RawVerse_createModule", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_RawVerse_createModule__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_RawVerse_createModule__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'RawVerse_createModule'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    sword::RawVerse::createModule(char const *,char const *)\n"
    "    sword::RawVerse::createModule(char const *)\n");
  return 0;
}


SWIGINTERN PyObject *RawVerse_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_sword__RawVerse, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *RawVerse_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN int Swig_var_zVerse_uniqueIndexID_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable zVerse_uniqueIndexID is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_zVerse_uniqueIndexID_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(sword::zVerse::uniqueIndexID);
  return pyobj;
}


SWIGINTERN PyObject *_wrap_new_zVerse__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  int arg2 ;
  int arg3 ;
  sword::SWCompress *arg4 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  sword::zVerse *result = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_zVerse" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_zVerse" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_zVerse" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_sword__SWCompress, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_zVerse" "', argument " "4"" of type '" "sword::SWCompress *""'"); 
  }
  arg4 = reinterpret_cast< sword::SWCompress * >(argp4);
  {
    try {
      result = (sword::zVerse *)new sword::zVerse((char const *)arg1,arg2,arg3,arg4); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__zVerse, SWIG_POINTER_NEW |  0 );
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_zVerse__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  int arg2 ;
  int arg3 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  sword::zVerse *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_zVerse" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_zVerse" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_zVerse" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  {
    try {
      result = (sword::zVerse *)new sword::zVerse((char const *)arg1,arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__zVerse, SWIG_POINTER_NEW |  0 );
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_zVerse__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  int arg2 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  sword::zVerse *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_zVerse" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_zVerse" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    try {
      result = (sword::zVerse *)new sword::zVerse((char const *)arg1,arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__zVerse, SWIG_POINTER_NEW |  0 );
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_zVerse__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  sword::zVerse *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_zVerse" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  {
    try {
      result = (sword::zVerse *)new sword::zVerse((char const *)arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__zVerse, SWIG_POINTER_NEW |  0 );
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_zVerse(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_zVerse", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_zVerse__SWIG_3(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_zVerse__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_zVerse__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_sword__SWCompress, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_new_zVerse__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_zVerse'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    sword::zVerse::zVerse(char const *,int,int,sword::SWCompress *)\n"
    "    sword::zVerse::zVerse(char const *,int,int)\n"
    "    sword::zVerse::zVerse(char const *,int)\n"
    "    sword::zVerse::zVerse(char const *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_zVerse(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::zVerse *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__zVerse, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_zVerse" "', argument " "1"" of type '" "sword::zVerse *""'"); 
  }
  arg1 = reinterpret_cast< sword::zVerse * >(argp1);
  {
    try {
      delete arg1; 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_zVerse_findOffset(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::zVerse *arg1 = 0 ;
  char arg2 ;
  long arg3 ;
  long *arg4 = 0 ;
  unsigned short *arg5 = 0 ;
  unsigned long *arg6 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char val2 ;
  int ecode2 = 0 ;
  long val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  PyObject *swig_obj[6] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "zVerse_findOffset", 6, 6, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__zVerse, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "zVerse_findOffset" "', argument " "1"" of type '" "sword::zVerse const *""'"); 
  }
  arg1 = reinterpret_cast< sword::zVerse * >(argp1);
  ecode2 = SWIG_AsVal_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "zVerse_findOffset" "', argument " "2"" of type '" "char""'");
  } 
  arg2 = static_cast< char >(val2);
  ecode3 = SWIG_AsVal_long(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "zVerse_findOffset" "', argument " "3"" of type '" "long""'");
  } 
  arg3 = static_cast< long >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_long, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "zVerse_findOffset" "', argument " "4"" of type '" "long *""'"); 
  }
  arg4 = reinterpret_cast< long * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5,SWIGTYPE_p_unsigned_short, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "zVerse_findOffset" "', argument " "5"" of type '" "unsigned short *""'"); 
  }
  arg5 = reinterpret_cast< unsigned short * >(argp5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6,SWIGTYPE_p_unsigned_long, 0 |  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "zVerse_findOffset" "', argument " "6"" of type '" "unsigned long *""'"); 
  }
  arg6 = reinterpret_cast< unsigned long * >(argp6);
  {
    try {
      ((sword::zVerse const *)arg1)->findOffset(arg2,arg3,arg4,arg5,arg6); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_zVerse_zReadText(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::zVerse *arg1 = 0 ;
  char arg2 ;
  long arg3 ;
  unsigned short arg4 ;
  unsigned long arg5 ;
  sword::SWBuf *arg6 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char val2 ;
  int ecode2 = 0 ;
  long val3 ;
  int ecode3 = 0 ;
  unsigned short val4 ;
  int ecode4 = 0 ;
  unsigned long val5 ;
  int ecode5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  PyObject *swig_obj[6] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "zVerse_zReadText", 6, 6, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__zVerse, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "zVerse_zReadText" "', argument " "1"" of type '" "sword::zVerse const *""'"); 
  }
  arg1 = reinterpret_cast< sword::zVerse * >(argp1);
  ecode2 = SWIG_AsVal_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "zVerse_zReadText" "', argument " "2"" of type '" "char""'");
  } 
  arg2 = static_cast< char >(val2);
  ecode3 = SWIG_AsVal_long(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "zVerse_zReadText" "', argument " "3"" of type '" "long""'");
  } 
  arg3 = static_cast< long >(val3);
  ecode4 = SWIG_AsVal_unsigned_SS_short(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "zVerse_zReadText" "', argument " "4"" of type '" "unsigned short""'");
  } 
  arg4 = static_cast< unsigned short >(val4);
  ecode5 = SWIG_AsVal_unsigned_SS_long(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "zVerse_zReadText" "', argument " "5"" of type '" "unsigned long""'");
  } 
  arg5 = static_cast< unsigned long >(val5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_sword__SWBuf,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "zVerse_zReadText" "', argument " "6"" of type '" "sword::SWBuf &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "zVerse_zReadText" "', argument " "6"" of type '" "sword::SWBuf &""'"); 
  }
  arg6 = reinterpret_cast< sword::SWBuf * >(argp6);
  {
    try {
      ((sword::zVerse const *)arg1)->zReadText(arg2,arg3,arg4,arg5,*arg6); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_zVerse_rawZFilter__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::zVerse *arg1 = 0 ;
  sword::SWBuf *arg2 = 0 ;
  char arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  char val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__zVerse, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "zVerse_rawZFilter" "', argument " "1"" of type '" "sword::zVerse const *""'"); 
  }
  arg1 = reinterpret_cast< sword::zVerse * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_sword__SWBuf,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "zVerse_rawZFilter" "', argument " "2"" of type '" "sword::SWBuf &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "zVerse_rawZFilter" "', argument " "2"" of type '" "sword::SWBuf &""'"); 
  }
  arg2 = reinterpret_cast< sword::SWBuf * >(argp2);
  ecode3 = SWIG_AsVal_char(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "zVerse_rawZFilter" "', argument " "3"" of type '" "char""'");
  } 
  arg3 = static_cast< char >(val3);
  {
    try {
      ((sword::zVerse const *)arg1)->rawZFilter(*arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_zVerse_rawZFilter__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::zVerse *arg1 = 0 ;
  sword::SWBuf *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__zVerse, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "zVerse_rawZFilter" "', argument " "1"" of type '" "sword::zVerse const *""'"); 
  }
  arg1 = reinterpret_cast< sword::zVerse * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_sword__SWBuf,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "zVerse_rawZFilter" "', argument " "2"" of type '" "sword::SWBuf &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "zVerse_rawZFilter" "', argument " "2"" of type '" "sword::SWBuf &""'"); 
  }
  arg2 = reinterpret_cast< sword::SWBuf * >(argp2);
  {
    try {
      ((sword::zVerse const *)arg1)->rawZFilter(*arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_zVerse_rawZFilter(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "zVerse_rawZFilter", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__zVerse, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_sword__SWBuf, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_zVerse_rawZFilter__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__zVerse, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_sword__SWBuf, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_char(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_zVerse_rawZFilter__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'zVerse_rawZFilter'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    sword::zVerse::rawZFilter(sword::SWBuf &,char) const\n"
    "    sword::zVerse::rawZFilter(sword::SWBuf &) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_zVerse_createModule__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  int arg2 ;
  char *arg3 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  char result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "zVerse_createModule" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "zVerse_createModule" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "zVerse_createModule" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  {
    try {
      result = (char)sword::zVerse::createModule((char const *)arg1,arg2,(char const *)arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_char(static_cast< char >(result));
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_zVerse_createModule__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  int arg2 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  char result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "zVerse_createModule" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "zVerse_createModule" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    try {
      result = (char)sword::zVerse::createModule((char const *)arg1,arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_char(static_cast< char >(result));
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_zVerse_createModule(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "zVerse_createModule", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_zVerse_createModule__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_zVerse_createModule__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'zVerse_createModule'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    sword::zVerse::createModule(char const *,int,char const *)\n"
    "    sword::zVerse::createModule(char const *,int)\n");
  return 0;
}


SWIGINTERN PyObject *zVerse_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_sword__zVerse, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *zVerse_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN int Swig_var_RawStr_nl_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RawStr_nl is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RawStr_nl_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(sword::RawStr::nl));
  return pyobj;
}


SWIGINTERN PyObject *_wrap_new_RawStr__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  int arg2 ;
  bool arg3 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  sword::RawStr *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_RawStr" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_RawStr" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_RawStr" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    try {
      result = (sword::RawStr *)new sword::RawStr((char const *)arg1,arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__RawStr, SWIG_POINTER_NEW |  0 );
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RawStr__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  int arg2 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  sword::RawStr *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_RawStr" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_RawStr" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    try {
      result = (sword::RawStr *)new sword::RawStr((char const *)arg1,arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__RawStr, SWIG_POINTER_NEW |  0 );
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RawStr__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  sword::RawStr *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_RawStr" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  {
    try {
      result = (sword::RawStr *)new sword::RawStr((char const *)arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__RawStr, SWIG_POINTER_NEW |  0 );
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RawStr(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_RawStr", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_RawStr__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_RawStr__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_RawStr__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_RawStr'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    sword::RawStr::RawStr(char const *,int,bool)\n"
    "    sword::RawStr::RawStr(char const *,int)\n"
    "    sword::RawStr::RawStr(char const *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_RawStr(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::RawStr *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__RawStr, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RawStr" "', argument " "1"" of type '" "sword::RawStr *""'"); 
  }
  arg1 = reinterpret_cast< sword::RawStr * >(argp1);
  {
    try {
      delete arg1; 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RawStr_getIDXBuf(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::RawStr *arg1 = 0 ;
  long arg2 ;
  char **arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  long val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "RawStr_getIDXBuf", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__RawStr, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RawStr_getIDXBuf" "', argument " "1"" of type '" "sword::RawStr const *""'"); 
  }
  arg1 = reinterpret_cast< sword::RawStr * >(argp1);
  ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RawStr_getIDXBuf" "', argument " "2"" of type '" "long""'");
  } 
  arg2 = static_cast< long >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_p_char, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RawStr_getIDXBuf" "', argument " "3"" of type '" "char **""'"); 
  }
  arg3 = reinterpret_cast< char ** >(argp3);
  {
    try {
      ((sword::RawStr const *)arg1)->getIDXBuf(arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RawStr_getIDXBufDat(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::RawStr *arg1 = 0 ;
  long arg2 ;
  char **arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  long val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "RawStr_getIDXBufDat", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__RawStr, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RawStr_getIDXBufDat" "', argument " "1"" of type '" "sword::RawStr const *""'"); 
  }
  arg1 = reinterpret_cast< sword::RawStr * >(argp1);
  ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RawStr_getIDXBufDat" "', argument " "2"" of type '" "long""'");
  } 
  arg2 = static_cast< long >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_p_char, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RawStr_getIDXBufDat" "', argument " "3"" of type '" "char **""'"); 
  }
  arg3 = reinterpret_cast< char ** >(argp3);
  {
    try {
      ((sword::RawStr const *)arg1)->getIDXBufDat(arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RawStr_findOffset__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::RawStr *arg1 = 0 ;
  char *arg2 = 0 ;
  SW_u32 *arg3 = 0 ;
  SW_u16 *arg4 = 0 ;
  long arg5 ;
  SW_u32 *arg6 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  long val5 ;
  int ecode5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  signed char result;
  
  (void)self;
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__RawStr, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RawStr_findOffset" "', argument " "1"" of type '" "sword::RawStr const *""'"); 
  }
  arg1 = reinterpret_cast< sword::RawStr * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RawStr_findOffset" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_SW_u32, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RawStr_findOffset" "', argument " "3"" of type '" "SW_u32 *""'"); 
  }
  arg3 = reinterpret_cast< SW_u32 * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_SW_u16, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "RawStr_findOffset" "', argument " "4"" of type '" "SW_u16 *""'"); 
  }
  arg4 = reinterpret_cast< SW_u16 * >(argp4);
  ecode5 = SWIG_AsVal_long(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "RawStr_findOffset" "', argument " "5"" of type '" "long""'");
  } 
  arg5 = static_cast< long >(val5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6,SWIGTYPE_p_SW_u32, 0 |  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "RawStr_findOffset" "', argument " "6"" of type '" "SW_u32 *""'"); 
  }
  arg6 = reinterpret_cast< SW_u32 * >(argp6);
  {
    try {
      result = (signed char)((sword::RawStr const *)arg1)->findOffset((char const *)arg2,arg3,arg4,arg5,arg6); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_signed_SS_char(static_cast< signed char >(result));
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_RawStr_findOffset__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::RawStr *arg1 = 0 ;
  char *arg2 = 0 ;
  SW_u32 *arg3 = 0 ;
  SW_u16 *arg4 = 0 ;
  long arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  long val5 ;
  int ecode5 = 0 ;
  signed char result;
  
  (void)self;
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__RawStr, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RawStr_findOffset" "', argument " "1"" of type '" "sword::RawStr const *""'"); 
  }
  arg1 = reinterpret_cast< sword::RawStr * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RawStr_findOffset" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_SW_u32, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RawStr_findOffset" "', argument " "3"" of type '" "SW_u32 *""'"); 
  }
  arg3 = reinterpret_cast< SW_u32 * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_SW_u16, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "RawStr_findOffset" "', argument " "4"" of type '" "SW_u16 *""'"); 
  }
  arg4 = reinterpret_cast< SW_u16 * >(argp4);
  ecode5 = SWIG_AsVal_long(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "RawStr_findOffset" "', argument " "5"" of type '" "long""'");
  } 
  arg5 = static_cast< long >(val5);
  {
    try {
      result = (signed char)((sword::RawStr const *)arg1)->findOffset((char const *)arg2,arg3,arg4,arg5); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_signed_SS_char(static_cast< signed char >(result));
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_RawStr_findOffset__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::RawStr *arg1 = 0 ;
  char *arg2 = 0 ;
  SW_u32 *arg3 = 0 ;
  SW_u16 *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  signed char result;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__RawStr, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RawStr_findOffset" "', argument " "1"" of type '" "sword::RawStr const *""'"); 
  }
  arg1 = reinterpret_cast< sword::RawStr * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RawStr_findOffset" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_SW_u32, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RawStr_findOffset" "', argument " "3"" of type '" "SW_u32 *""'"); 
  }
  arg3 = reinterpret_cast< SW_u32 * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_SW_u16, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "RawStr_findOffset" "', argument " "4"" of type '" "SW_u16 *""'"); 
  }
  arg4 = reinterpret_cast< SW_u16 * >(argp4);
  {
    try {
      result = (signed char)((sword::RawStr const *)arg1)->findOffset((char const *)arg2,arg3,arg4); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_signed_SS_char(static_cast< signed char >(result));
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_RawStr_findOffset(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[7] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "RawStr_findOffset", 0, 6, argv))) SWIG_fail;
  --argc;
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__RawStr, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_SW_u32, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_SW_u16, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_RawStr_findOffset__SWIG_2(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__RawStr, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_SW_u32, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_SW_u16, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_long(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_RawStr_findOffset__SWIG_1(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__RawStr, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_SW_u32, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_SW_u16, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_long(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_SW_u32, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                return _wrap_RawStr_findOffset__SWIG_0(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'RawStr_findOffset'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    sword::RawStr::findOffset(char const *,SW_u32 *,SW_u16 *,long,SW_u32 *) const\n"
    "    sword::RawStr::findOffset(char const *,SW_u32 *,SW_u16 *,long) const\n"
    "    sword::RawStr::findOffset(char const *,SW_u32 *,SW_u16 *) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_RawStr_readText(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::RawStr *arg1 = 0 ;
  SW_u32 arg2 ;
  SW_u16 *arg3 = 0 ;
  char **arg4 = 0 ;
  sword::SWBuf *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  PyObject *swig_obj[5] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "RawStr_readText", 5, 5, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__RawStr, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RawStr_readText" "', argument " "1"" of type '" "sword::RawStr const *""'"); 
  }
  arg1 = reinterpret_cast< sword::RawStr * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SW_u32,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RawStr_readText" "', argument " "2"" of type '" "SW_u32""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "RawStr_readText" "', argument " "2"" of type '" "SW_u32""'");
    } else {
      SW_u32 * temp = reinterpret_cast< SW_u32 * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_SW_u16, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RawStr_readText" "', argument " "3"" of type '" "SW_u16 *""'"); 
  }
  arg3 = reinterpret_cast< SW_u16 * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_p_char, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "RawStr_readText" "', argument " "4"" of type '" "char **""'"); 
  }
  arg4 = reinterpret_cast< char ** >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_sword__SWBuf,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "RawStr_readText" "', argument " "5"" of type '" "sword::SWBuf &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "RawStr_readText" "', argument " "5"" of type '" "sword::SWBuf &""'"); 
  }
  arg5 = reinterpret_cast< sword::SWBuf * >(argp5);
  {
    try {
      ((sword::RawStr const *)arg1)->readText(SWIG_STD_MOVE(arg2),arg3,arg4,*arg5); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RawStr_createModule(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  PyObject *swig_obj[1] ;
  signed char result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RawStr_createModule" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  {
    try {
      result = (signed char)sword::RawStr::createModule((char const *)arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_signed_SS_char(static_cast< signed char >(result));
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return NULL;
}


SWIGINTERN PyObject *RawStr_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_sword__RawStr, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *RawStr_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN int Swig_var_RawStr4_nl_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RawStr4_nl is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RawStr4_nl_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(sword::RawStr4::nl));
  return pyobj;
}


SWIGINTERN PyObject *_wrap_new_RawStr4__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  int arg2 ;
  bool arg3 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  sword::RawStr4 *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_RawStr4" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_RawStr4" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_RawStr4" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    try {
      result = (sword::RawStr4 *)new sword::RawStr4((char const *)arg1,arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__RawStr4, SWIG_POINTER_NEW |  0 );
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RawStr4__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  int arg2 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  sword::RawStr4 *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_RawStr4" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_RawStr4" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    try {
      result = (sword::RawStr4 *)new sword::RawStr4((char const *)arg1,arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__RawStr4, SWIG_POINTER_NEW |  0 );
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RawStr4__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  sword::RawStr4 *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_RawStr4" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  {
    try {
      result = (sword::RawStr4 *)new sword::RawStr4((char const *)arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__RawStr4, SWIG_POINTER_NEW |  0 );
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RawStr4(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_RawStr4", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_RawStr4__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_RawStr4__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_RawStr4__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_RawStr4'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    sword::RawStr4::RawStr4(char const *,int,bool)\n"
    "    sword::RawStr4::RawStr4(char const *,int)\n"
    "    sword::RawStr4::RawStr4(char const *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_RawStr4(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::RawStr4 *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__RawStr4, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RawStr4" "', argument " "1"" of type '" "sword::RawStr4 *""'"); 
  }
  arg1 = reinterpret_cast< sword::RawStr4 * >(argp1);
  {
    try {
      delete arg1; 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RawStr4_getIDXBuf(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::RawStr4 *arg1 = 0 ;
  long arg2 ;
  char **arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  long val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "RawStr4_getIDXBuf", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__RawStr4, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RawStr4_getIDXBuf" "', argument " "1"" of type '" "sword::RawStr4 const *""'"); 
  }
  arg1 = reinterpret_cast< sword::RawStr4 * >(argp1);
  ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RawStr4_getIDXBuf" "', argument " "2"" of type '" "long""'");
  } 
  arg2 = static_cast< long >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_p_char, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RawStr4_getIDXBuf" "', argument " "3"" of type '" "char **""'"); 
  }
  arg3 = reinterpret_cast< char ** >(argp3);
  {
    try {
      ((sword::RawStr4 const *)arg1)->getIDXBuf(arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RawStr4_getIDXBufDat(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::RawStr4 *arg1 = 0 ;
  long arg2 ;
  char **arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  long val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "RawStr4_getIDXBufDat", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__RawStr4, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RawStr4_getIDXBufDat" "', argument " "1"" of type '" "sword::RawStr4 const *""'"); 
  }
  arg1 = reinterpret_cast< sword::RawStr4 * >(argp1);
  ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RawStr4_getIDXBufDat" "', argument " "2"" of type '" "long""'");
  } 
  arg2 = static_cast< long >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_p_char, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RawStr4_getIDXBufDat" "', argument " "3"" of type '" "char **""'"); 
  }
  arg3 = reinterpret_cast< char ** >(argp3);
  {
    try {
      ((sword::RawStr4 const *)arg1)->getIDXBufDat(arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RawStr4_findOffset__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::RawStr4 *arg1 = 0 ;
  char *arg2 = 0 ;
  SW_u32 *arg3 = 0 ;
  SW_u32 *arg4 = 0 ;
  long arg5 ;
  SW_u32 *arg6 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  long val5 ;
  int ecode5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  signed char result;
  
  (void)self;
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__RawStr4, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RawStr4_findOffset" "', argument " "1"" of type '" "sword::RawStr4 const *""'"); 
  }
  arg1 = reinterpret_cast< sword::RawStr4 * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RawStr4_findOffset" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_SW_u32, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RawStr4_findOffset" "', argument " "3"" of type '" "SW_u32 *""'"); 
  }
  arg3 = reinterpret_cast< SW_u32 * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_SW_u32, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "RawStr4_findOffset" "', argument " "4"" of type '" "SW_u32 *""'"); 
  }
  arg4 = reinterpret_cast< SW_u32 * >(argp4);
  ecode5 = SWIG_AsVal_long(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "RawStr4_findOffset" "', argument " "5"" of type '" "long""'");
  } 
  arg5 = static_cast< long >(val5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6,SWIGTYPE_p_SW_u32, 0 |  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "RawStr4_findOffset" "', argument " "6"" of type '" "SW_u32 *""'"); 
  }
  arg6 = reinterpret_cast< SW_u32 * >(argp6);
  {
    try {
      result = (signed char)((sword::RawStr4 const *)arg1)->findOffset((char const *)arg2,arg3,arg4,arg5,arg6); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_signed_SS_char(static_cast< signed char >(result));
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_RawStr4_findOffset__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::RawStr4 *arg1 = 0 ;
  char *arg2 = 0 ;
  SW_u32 *arg3 = 0 ;
  SW_u32 *arg4 = 0 ;
  long arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  long val5 ;
  int ecode5 = 0 ;
  signed char result;
  
  (void)self;
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__RawStr4, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RawStr4_findOffset" "', argument " "1"" of type '" "sword::RawStr4 const *""'"); 
  }
  arg1 = reinterpret_cast< sword::RawStr4 * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RawStr4_findOffset" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_SW_u32, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RawStr4_findOffset" "', argument " "3"" of type '" "SW_u32 *""'"); 
  }
  arg3 = reinterpret_cast< SW_u32 * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_SW_u32, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "RawStr4_findOffset" "', argument " "4"" of type '" "SW_u32 *""'"); 
  }
  arg4 = reinterpret_cast< SW_u32 * >(argp4);
  ecode5 = SWIG_AsVal_long(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "RawStr4_findOffset" "', argument " "5"" of type '" "long""'");
  } 
  arg5 = static_cast< long >(val5);
  {
    try {
      result = (signed char)((sword::RawStr4 const *)arg1)->findOffset((char const *)arg2,arg3,arg4,arg5); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_signed_SS_char(static_cast< signed char >(result));
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_RawStr4_findOffset__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::RawStr4 *arg1 = 0 ;
  char *arg2 = 0 ;
  SW_u32 *arg3 = 0 ;
  SW_u32 *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  signed char result;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__RawStr4, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RawStr4_findOffset" "', argument " "1"" of type '" "sword::RawStr4 const *""'"); 
  }
  arg1 = reinterpret_cast< sword::RawStr4 * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RawStr4_findOffset" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_SW_u32, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RawStr4_findOffset" "', argument " "3"" of type '" "SW_u32 *""'"); 
  }
  arg3 = reinterpret_cast< SW_u32 * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_SW_u32, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "RawStr4_findOffset" "', argument " "4"" of type '" "SW_u32 *""'"); 
  }
  arg4 = reinterpret_cast< SW_u32 * >(argp4);
  {
    try {
      result = (signed char)((sword::RawStr4 const *)arg1)->findOffset((char const *)arg2,arg3,arg4); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_signed_SS_char(static_cast< signed char >(result));
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_RawStr4_findOffset(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[7] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "RawStr4_findOffset", 0, 6, argv))) SWIG_fail;
  --argc;
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__RawStr4, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_SW_u32, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_SW_u32, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_RawStr4_findOffset__SWIG_2(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__RawStr4, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_SW_u32, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_SW_u32, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_long(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_RawStr4_findOffset__SWIG_1(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__RawStr4, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_SW_u32, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_SW_u32, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_long(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_SW_u32, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                return _wrap_RawStr4_findOffset__SWIG_0(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'RawStr4_findOffset'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    sword::RawStr4::findOffset(char const *,SW_u32 *,SW_u32 *,long,SW_u32 *) const\n"
    "    sword::RawStr4::findOffset(char const *,SW_u32 *,SW_u32 *,long) const\n"
    "    sword::RawStr4::findOffset(char const *,SW_u32 *,SW_u32 *) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_RawStr4_readText(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::RawStr4 *arg1 = 0 ;
  SW_u32 arg2 ;
  SW_u32 *arg3 = 0 ;
  char **arg4 = 0 ;
  sword::SWBuf *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  PyObject *swig_obj[5] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "RawStr4_readText", 5, 5, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__RawStr4, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RawStr4_readText" "', argument " "1"" of type '" "sword::RawStr4 const *""'"); 
  }
  arg1 = reinterpret_cast< sword::RawStr4 * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SW_u32,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RawStr4_readText" "', argument " "2"" of type '" "SW_u32""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "RawStr4_readText" "', argument " "2"" of type '" "SW_u32""'");
    } else {
      SW_u32 * temp = reinterpret_cast< SW_u32 * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_SW_u32, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RawStr4_readText" "', argument " "3"" of type '" "SW_u32 *""'"); 
  }
  arg3 = reinterpret_cast< SW_u32 * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_p_char, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "RawStr4_readText" "', argument " "4"" of type '" "char **""'"); 
  }
  arg4 = reinterpret_cast< char ** >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_sword__SWBuf,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "RawStr4_readText" "', argument " "5"" of type '" "sword::SWBuf &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "RawStr4_readText" "', argument " "5"" of type '" "sword::SWBuf &""'"); 
  }
  arg5 = reinterpret_cast< sword::SWBuf * >(argp5);
  {
    try {
      ((sword::RawStr4 const *)arg1)->readText(SWIG_STD_MOVE(arg2),arg3,arg4,*arg5); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RawStr4_createModule(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  PyObject *swig_obj[1] ;
  signed char result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RawStr4_createModule" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  {
    try {
      result = (signed char)sword::RawStr4::createModule((char const *)arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_signed_SS_char(static_cast< signed char >(result));
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return NULL;
}


SWIGINTERN PyObject *RawStr4_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_sword__RawStr4, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *RawStr4_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_zStr__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  int arg2 ;
  long arg3 ;
  sword::SWCompress *arg4 = 0 ;
  bool arg5 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  long val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  sword::zStr *result = 0 ;
  
  (void)self;
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_zStr" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_zStr" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_long(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_zStr" "', argument " "3"" of type '" "long""'");
  } 
  arg3 = static_cast< long >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_sword__SWCompress, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_zStr" "', argument " "4"" of type '" "sword::SWCompress *""'"); 
  }
  arg4 = reinterpret_cast< sword::SWCompress * >(argp4);
  ecode5 = SWIG_AsVal_bool(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_zStr" "', argument " "5"" of type '" "bool""'");
  } 
  arg5 = static_cast< bool >(val5);
  {
    try {
      result = (sword::zStr *)new sword::zStr((char const *)arg1,arg2,arg3,arg4,arg5); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__zStr, SWIG_POINTER_NEW |  0 );
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_zStr__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  int arg2 ;
  long arg3 ;
  sword::SWCompress *arg4 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  long val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  sword::zStr *result = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_zStr" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_zStr" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_long(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_zStr" "', argument " "3"" of type '" "long""'");
  } 
  arg3 = static_cast< long >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_sword__SWCompress, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_zStr" "', argument " "4"" of type '" "sword::SWCompress *""'"); 
  }
  arg4 = reinterpret_cast< sword::SWCompress * >(argp4);
  {
    try {
      result = (sword::zStr *)new sword::zStr((char const *)arg1,arg2,arg3,arg4); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__zStr, SWIG_POINTER_NEW |  0 );
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_zStr__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  int arg2 ;
  long arg3 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  long val3 ;
  int ecode3 = 0 ;
  sword::zStr *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_zStr" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_zStr" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_long(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_zStr" "', argument " "3"" of type '" "long""'");
  } 
  arg3 = static_cast< long >(val3);
  {
    try {
      result = (sword::zStr *)new sword::zStr((char const *)arg1,arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__zStr, SWIG_POINTER_NEW |  0 );
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_zStr__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  int arg2 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  sword::zStr *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_zStr" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_zStr" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    try {
      result = (sword::zStr *)new sword::zStr((char const *)arg1,arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__zStr, SWIG_POINTER_NEW |  0 );
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_zStr__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  sword::zStr *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_zStr" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  {
    try {
      result = (sword::zStr *)new sword::zStr((char const *)arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__zStr, SWIG_POINTER_NEW |  0 );
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_zStr(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_zStr", 0, 5, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_zStr__SWIG_4(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_zStr__SWIG_3(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_long(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_zStr__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_long(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_sword__SWCompress, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_new_zStr__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_long(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_sword__SWCompress, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_bool(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_new_zStr__SWIG_0(self, argc, argv);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_zStr'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    sword::zStr::zStr(char const *,int,long,sword::SWCompress *,bool)\n"
    "    sword::zStr::zStr(char const *,int,long,sword::SWCompress *)\n"
    "    sword::zStr::zStr(char const *,int,long)\n"
    "    sword::zStr::zStr(char const *,int)\n"
    "    sword::zStr::zStr(char const *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_zStr(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::zStr *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__zStr, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_zStr" "', argument " "1"" of type '" "sword::zStr *""'"); 
  }
  arg1 = reinterpret_cast< sword::zStr * >(argp1);
  {
    try {
      delete arg1; 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_zStr_findKeyIndex__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::zStr *arg1 = 0 ;
  char *arg2 = 0 ;
  long *arg3 = 0 ;
  long arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  long val4 ;
  int ecode4 = 0 ;
  signed char result;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__zStr, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "zStr_findKeyIndex" "', argument " "1"" of type '" "sword::zStr const *""'"); 
  }
  arg1 = reinterpret_cast< sword::zStr * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "zStr_findKeyIndex" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_long, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "zStr_findKeyIndex" "', argument " "3"" of type '" "long *""'"); 
  }
  arg3 = reinterpret_cast< long * >(argp3);
  ecode4 = SWIG_AsVal_long(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "zStr_findKeyIndex" "', argument " "4"" of type '" "long""'");
  } 
  arg4 = static_cast< long >(val4);
  {
    try {
      result = (signed char)((sword::zStr const *)arg1)->findKeyIndex((char const *)arg2,arg3,arg4); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_signed_SS_char(static_cast< signed char >(result));
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_zStr_findKeyIndex__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::zStr *arg1 = 0 ;
  char *arg2 = 0 ;
  long *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  signed char result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__zStr, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "zStr_findKeyIndex" "', argument " "1"" of type '" "sword::zStr const *""'"); 
  }
  arg1 = reinterpret_cast< sword::zStr * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "zStr_findKeyIndex" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_long, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "zStr_findKeyIndex" "', argument " "3"" of type '" "long *""'"); 
  }
  arg3 = reinterpret_cast< long * >(argp3);
  {
    try {
      result = (signed char)((sword::zStr const *)arg1)->findKeyIndex((char const *)arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_signed_SS_char(static_cast< signed char >(result));
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_zStr_findKeyIndex(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "zStr_findKeyIndex", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__zStr, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_long, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_zStr_findKeyIndex__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__zStr, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_long, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_long(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_zStr_findKeyIndex__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'zStr_findKeyIndex'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    sword::zStr::findKeyIndex(char const *,long *,long) const\n"
    "    sword::zStr::findKeyIndex(char const *,long *) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_zStr_getText(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::zStr *arg1 = 0 ;
  long arg2 ;
  char **arg3 = 0 ;
  char **arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  long val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PyObject *swig_obj[4] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "zStr_getText", 4, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__zStr, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "zStr_getText" "', argument " "1"" of type '" "sword::zStr const *""'"); 
  }
  arg1 = reinterpret_cast< sword::zStr * >(argp1);
  ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "zStr_getText" "', argument " "2"" of type '" "long""'");
  } 
  arg2 = static_cast< long >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_p_char, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "zStr_getText" "', argument " "3"" of type '" "char **""'"); 
  }
  arg3 = reinterpret_cast< char ** >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_p_char, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "zStr_getText" "', argument " "4"" of type '" "char **""'"); 
  }
  arg4 = reinterpret_cast< char ** >(argp4);
  {
    try {
      ((sword::zStr const *)arg1)->getText(arg2,arg3,arg4); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_zStr_setText__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::zStr *arg1 = 0 ;
  char *arg2 = 0 ;
  char *arg3 = 0 ;
  long arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  long val4 ;
  int ecode4 = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__zStr, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "zStr_setText" "', argument " "1"" of type '" "sword::zStr *""'"); 
  }
  arg1 = reinterpret_cast< sword::zStr * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "zStr_setText" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "zStr_setText" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  ecode4 = SWIG_AsVal_long(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "zStr_setText" "', argument " "4"" of type '" "long""'");
  } 
  arg4 = static_cast< long >(val4);
  {
    try {
      (arg1)->setText((char const *)arg2,(char const *)arg3,arg4); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_zStr_setText__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::zStr *arg1 = 0 ;
  char *arg2 = 0 ;
  char *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__zStr, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "zStr_setText" "', argument " "1"" of type '" "sword::zStr *""'"); 
  }
  arg1 = reinterpret_cast< sword::zStr * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "zStr_setText" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "zStr_setText" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  {
    try {
      (arg1)->setText((char const *)arg2,(char const *)arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_zStr_setText(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "zStr_setText", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__zStr, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_zStr_setText__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__zStr, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_long(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_zStr_setText__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'zStr_setText'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    sword::zStr::setText(char const *,char const *,long)\n"
    "    sword::zStr::setText(char const *,char const *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_zStr_linkEntry(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::zStr *arg1 = 0 ;
  char *arg2 = 0 ;
  char *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "zStr_linkEntry", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__zStr, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "zStr_linkEntry" "', argument " "1"" of type '" "sword::zStr *""'"); 
  }
  arg1 = reinterpret_cast< sword::zStr * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "zStr_linkEntry" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "zStr_linkEntry" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  {
    try {
      (arg1)->linkEntry((char const *)arg2,(char const *)arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_zStr_rawZFilter__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::zStr *arg1 = 0 ;
  sword::SWBuf *arg2 = 0 ;
  char arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  char val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__zStr, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "zStr_rawZFilter" "', argument " "1"" of type '" "sword::zStr const *""'"); 
  }
  arg1 = reinterpret_cast< sword::zStr * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_sword__SWBuf,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "zStr_rawZFilter" "', argument " "2"" of type '" "sword::SWBuf &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "zStr_rawZFilter" "', argument " "2"" of type '" "sword::SWBuf &""'"); 
  }
  arg2 = reinterpret_cast< sword::SWBuf * >(argp2);
  ecode3 = SWIG_AsVal_char(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "zStr_rawZFilter" "', argument " "3"" of type '" "char""'");
  } 
  arg3 = static_cast< char >(val3);
  {
    try {
      ((sword::zStr const *)arg1)->rawZFilter(*arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_zStr_rawZFilter__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::zStr *arg1 = 0 ;
  sword::SWBuf *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__zStr, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "zStr_rawZFilter" "', argument " "1"" of type '" "sword::zStr const *""'"); 
  }
  arg1 = reinterpret_cast< sword::zStr * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_sword__SWBuf,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "zStr_rawZFilter" "', argument " "2"" of type '" "sword::SWBuf &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "zStr_rawZFilter" "', argument " "2"" of type '" "sword::SWBuf &""'"); 
  }
  arg2 = reinterpret_cast< sword::SWBuf * >(argp2);
  {
    try {
      ((sword::zStr const *)arg1)->rawZFilter(*arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_zStr_rawZFilter(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "zStr_rawZFilter", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__zStr, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_sword__SWBuf, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_zStr_rawZFilter__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__zStr, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_sword__SWBuf, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_char(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_zStr_rawZFilter__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'zStr_rawZFilter'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    sword::zStr::rawZFilter(sword::SWBuf &,char) const\n"
    "    sword::zStr::rawZFilter(sword::SWBuf &) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_zStr_createModule(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  PyObject *swig_obj[1] ;
  signed char result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "zStr_createModule" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  {
    try {
      result = (signed char)sword::zStr::createModule((char const *)arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_signed_SS_char(static_cast< signed char >(result));
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return NULL;
}


SWIGINTERN PyObject *zStr_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_sword__zStr, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *zStr_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SW_POSITION(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  char arg1 ;
  char val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[1] ;
  sword::SW_POSITION *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_char(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SW_POSITION" "', argument " "1"" of type '" "char""'");
  } 
  arg1 = static_cast< char >(val1);
  {
    try {
      result = (sword::SW_POSITION *)new sword::SW_POSITION(arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__SW_POSITION, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SW_POSITION_getPosition(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SW_POSITION *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SW_POSITION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SW_POSITION_getPosition" "', argument " "1"" of type '" "sword::SW_POSITION *""'"); 
  }
  arg1 = reinterpret_cast< sword::SW_POSITION * >(argp1);
  {
    try {
      result = (char)(arg1)->operator char(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_char(static_cast< char >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SW_POSITION(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SW_POSITION *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SW_POSITION, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SW_POSITION" "', argument " "1"" of type '" "sword::SW_POSITION *""'"); 
  }
  arg1 = reinterpret_cast< sword::SW_POSITION * >(argp1);
  {
    try {
      delete arg1; 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SW_POSITION_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_sword__SW_POSITION, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SW_POSITION_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SWKey__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  sword::SWKey *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SWKey" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  {
    try {
      result = (sword::SWKey *)new sword::SWKey((char const *)arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__SWKey, SWIG_POINTER_NEW |  0 );
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SWKey__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  sword::SWKey *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (sword::SWKey *)new sword::SWKey(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__SWKey, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SWKey__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::SWKey *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  sword::SWKey *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_sword__SWKey,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SWKey" "', argument " "1"" of type '" "sword::SWKey const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SWKey" "', argument " "1"" of type '" "sword::SWKey const &""'"); 
  }
  arg1 = reinterpret_cast< sword::SWKey * >(argp1);
  {
    try {
      result = (sword::SWKey *)new sword::SWKey((sword::SWKey const &)*arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__SWKey, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SWKey(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SWKey", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_SWKey__SWIG_1(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_sword__SWKey, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SWKey__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SWKey__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SWKey'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    sword::SWKey::SWKey(char const *)\n"
    "    sword::SWKey::SWKey()\n"
    "    sword::SWKey::SWKey(sword::SWKey const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SWKey(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWKey *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWKey, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SWKey" "', argument " "1"" of type '" "sword::SWKey *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWKey * >(argp1);
  {
    try {
      delete arg1; 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWKey_clone(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWKey *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  sword::SWKey *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWKey, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWKey_clone" "', argument " "1"" of type '" "sword::SWKey const *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWKey * >(argp1);
  {
    try {
      result = (sword::SWKey *)((sword::SWKey const *)arg1)->clone(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__SWKey, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWKey_isPersist(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWKey *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWKey, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWKey_isPersist" "', argument " "1"" of type '" "sword::SWKey const *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWKey * >(argp1);
  {
    try {
      result = (bool)((sword::SWKey const *)arg1)->isPersist(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWKey_setPersist(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWKey *arg1 = 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SWKey_setPersist", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWKey, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWKey_setPersist" "', argument " "1"" of type '" "sword::SWKey *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWKey * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SWKey_setPersist" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    try {
      (arg1)->setPersist(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWKey_popError(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWKey *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWKey, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWKey_popError" "', argument " "1"" of type '" "sword::SWKey *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWKey * >(argp1);
  {
    try {
      result = (char)(arg1)->popError(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_char(static_cast< char >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWKey_getError(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWKey *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWKey, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWKey_getError" "', argument " "1"" of type '" "sword::SWKey const *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWKey * >(argp1);
  {
    try {
      result = (char)((sword::SWKey const *)arg1)->getError(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_char(static_cast< char >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWKey_setError(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWKey *arg1 = 0 ;
  char arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SWKey_setError", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWKey, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWKey_setError" "', argument " "1"" of type '" "sword::SWKey *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWKey * >(argp1);
  ecode2 = SWIG_AsVal_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SWKey_setError" "', argument " "2"" of type '" "char""'");
  } 
  arg2 = static_cast< char >(val2);
  {
    try {
      (arg1)->setError(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWKey_setText(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWKey *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SWKey_setText", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWKey, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWKey_setText" "', argument " "1"" of type '" "sword::SWKey *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWKey * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SWKey_setText" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    try {
      (arg1)->setText((char const *)arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWKey_copyFrom(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWKey *arg1 = 0 ;
  sword::SWKey *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SWKey_copyFrom", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWKey, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWKey_copyFrom" "', argument " "1"" of type '" "sword::SWKey *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWKey * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_sword__SWKey,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SWKey_copyFrom" "', argument " "2"" of type '" "sword::SWKey const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SWKey_copyFrom" "', argument " "2"" of type '" "sword::SWKey const &""'"); 
  }
  arg2 = reinterpret_cast< sword::SWKey * >(argp2);
  {
    try {
      (arg1)->copyFrom((sword::SWKey const &)*arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWKey_positionFrom(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWKey *arg1 = 0 ;
  sword::SWKey *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SWKey_positionFrom", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWKey, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWKey_positionFrom" "', argument " "1"" of type '" "sword::SWKey *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWKey * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_sword__SWKey,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SWKey_positionFrom" "', argument " "2"" of type '" "sword::SWKey const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SWKey_positionFrom" "', argument " "2"" of type '" "sword::SWKey const &""'"); 
  }
  arg2 = reinterpret_cast< sword::SWKey * >(argp2);
  {
    try {
      (arg1)->positionFrom((sword::SWKey const &)*arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWKey_getText(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWKey *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWKey, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWKey_getText" "', argument " "1"" of type '" "sword::SWKey const *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWKey * >(argp1);
  {
    try {
      result = (char *)((sword::SWKey const *)arg1)->getText(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWKey_getShortText(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWKey *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWKey, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWKey_getShortText" "', argument " "1"" of type '" "sword::SWKey const *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWKey * >(argp1);
  {
    try {
      result = (char *)((sword::SWKey const *)arg1)->getShortText(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWKey_getRangeText(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWKey *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWKey, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWKey_getRangeText" "', argument " "1"" of type '" "sword::SWKey const *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWKey * >(argp1);
  {
    try {
      result = (char *)((sword::SWKey const *)arg1)->getRangeText(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWKey_getShortRangeText(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWKey *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWKey, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWKey_getShortRangeText" "', argument " "1"" of type '" "sword::SWKey const *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWKey * >(argp1);
  {
    try {
      result = (char *)((sword::SWKey const *)arg1)->getShortRangeText(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWKey_getOSISRefRangeText(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWKey *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWKey, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWKey_getOSISRefRangeText" "', argument " "1"" of type '" "sword::SWKey const *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWKey * >(argp1);
  {
    try {
      result = (char *)((sword::SWKey const *)arg1)->getOSISRefRangeText(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWKey_isBoundSet(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWKey *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWKey, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWKey_isBoundSet" "', argument " "1"" of type '" "sword::SWKey const *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWKey * >(argp1);
  {
    try {
      result = (bool)((sword::SWKey const *)arg1)->isBoundSet(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWKey_clearBounds(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWKey *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWKey, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWKey_clearBounds" "', argument " "1"" of type '" "sword::SWKey const *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWKey * >(argp1);
  {
    try {
      ((sword::SWKey const *)arg1)->clearBounds(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWKey_compare(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWKey *arg1 = 0 ;
  sword::SWKey *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SWKey_compare", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWKey, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWKey_compare" "', argument " "1"" of type '" "sword::SWKey *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWKey * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_sword__SWKey,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SWKey_compare" "', argument " "2"" of type '" "sword::SWKey const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SWKey_compare" "', argument " "2"" of type '" "sword::SWKey const &""'"); 
  }
  arg2 = reinterpret_cast< sword::SWKey * >(argp2);
  {
    try {
      result = (int)(arg1)->compare((sword::SWKey const &)*arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWKey_equals(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWKey *arg1 = 0 ;
  sword::SWKey *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SWKey_equals", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWKey, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWKey_equals" "', argument " "1"" of type '" "sword::SWKey *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWKey * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_sword__SWKey,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SWKey_equals" "', argument " "2"" of type '" "sword::SWKey const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SWKey_equals" "', argument " "2"" of type '" "sword::SWKey const &""'"); 
  }
  arg2 = reinterpret_cast< sword::SWKey * >(argp2);
  {
    try {
      result = (bool)(arg1)->equals((sword::SWKey const &)*arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWKey_setPosition(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWKey *arg1 = 0 ;
  SwigValueWrapper< sword::SW_POSITION > arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SWKey_setPosition", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWKey, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWKey_setPosition" "', argument " "1"" of type '" "sword::SWKey *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWKey * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_sword__SW_POSITION,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SWKey_setPosition" "', argument " "2"" of type '" "sword::SW_POSITION""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SWKey_setPosition" "', argument " "2"" of type '" "sword::SW_POSITION""'");
    } else {
      sword::SW_POSITION * temp = reinterpret_cast< sword::SW_POSITION * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    try {
      (arg1)->setPosition(SWIG_STD_MOVE(arg2)); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWKey_decrement__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::SWKey *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWKey, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWKey_decrement" "', argument " "1"" of type '" "sword::SWKey *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWKey * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SWKey_decrement" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    try {
      (arg1)->decrement(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWKey_decrement__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::SWKey *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWKey, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWKey_decrement" "', argument " "1"" of type '" "sword::SWKey *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWKey * >(argp1);
  {
    try {
      (arg1)->decrement(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWKey_decrement(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SWKey_decrement", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__SWKey, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SWKey_decrement__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__SWKey, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SWKey_decrement__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SWKey_decrement'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    sword::SWKey::decrement(int)\n"
    "    sword::SWKey::decrement()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SWKey_increment__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::SWKey *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWKey, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWKey_increment" "', argument " "1"" of type '" "sword::SWKey *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWKey * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SWKey_increment" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    try {
      (arg1)->increment(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWKey_increment__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::SWKey *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWKey, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWKey_increment" "', argument " "1"" of type '" "sword::SWKey *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWKey * >(argp1);
  {
    try {
      (arg1)->increment(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWKey_increment(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SWKey_increment", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__SWKey, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SWKey_increment__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__SWKey, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SWKey_increment__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SWKey_increment'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    sword::SWKey::increment(int)\n"
    "    sword::SWKey::increment()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SWKey_isTraversable(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWKey *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWKey, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWKey_isTraversable" "', argument " "1"" of type '" "sword::SWKey const *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWKey * >(argp1);
  {
    try {
      result = (bool)((sword::SWKey const *)arg1)->isTraversable(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWKey_getLocale(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWKey *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWKey, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWKey_getLocale" "', argument " "1"" of type '" "sword::SWKey const *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWKey * >(argp1);
  {
    try {
      result = (char *)((sword::SWKey const *)arg1)->getLocale(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWKey_setLocale(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWKey *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SWKey_setLocale", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWKey, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWKey_setLocale" "', argument " "1"" of type '" "sword::SWKey *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWKey * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SWKey_setLocale" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    try {
      (arg1)->setLocale((char const *)arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWKey_getIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWKey *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  long result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWKey, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWKey_getIndex" "', argument " "1"" of type '" "sword::SWKey const *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWKey * >(argp1);
  {
    try {
      result = (long)((sword::SWKey const *)arg1)->getIndex(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_long(static_cast< long >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWKey_setIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWKey *arg1 = 0 ;
  long arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  long val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SWKey_setIndex", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWKey, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWKey_setIndex" "', argument " "1"" of type '" "sword::SWKey *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWKey * >(argp1);
  ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SWKey_setIndex" "', argument " "2"" of type '" "long""'");
  } 
  arg2 = static_cast< long >(val2);
  {
    try {
      (arg1)->setIndex(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWKey___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWKey *arg1 = 0 ;
  sword::SWKey *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SWKey___eq__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWKey, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWKey___eq__" "', argument " "1"" of type '" "sword::SWKey *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWKey * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_sword__SWKey,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SWKey___eq__" "', argument " "2"" of type '" "sword::SWKey const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SWKey___eq__" "', argument " "2"" of type '" "sword::SWKey const &""'"); 
  }
  arg2 = reinterpret_cast< sword::SWKey * >(argp2);
  {
    try {
      result = (bool)(arg1)->operator ==((sword::SWKey const &)*arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SWKey___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWKey *arg1 = 0 ;
  sword::SWKey *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SWKey___ne__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWKey, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWKey___ne__" "', argument " "1"" of type '" "sword::SWKey *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWKey * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_sword__SWKey,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SWKey___ne__" "', argument " "2"" of type '" "sword::SWKey const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SWKey___ne__" "', argument " "2"" of type '" "sword::SWKey const &""'"); 
  }
  arg2 = reinterpret_cast< sword::SWKey * >(argp2);
  {
    try {
      result = (bool)(arg1)->operator !=((sword::SWKey const &)*arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SWKey___gt__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWKey *arg1 = 0 ;
  sword::SWKey *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SWKey___gt__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWKey, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWKey___gt__" "', argument " "1"" of type '" "sword::SWKey *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWKey * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_sword__SWKey,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SWKey___gt__" "', argument " "2"" of type '" "sword::SWKey const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SWKey___gt__" "', argument " "2"" of type '" "sword::SWKey const &""'"); 
  }
  arg2 = reinterpret_cast< sword::SWKey * >(argp2);
  {
    try {
      result = (bool)(arg1)->operator >((sword::SWKey const &)*arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SWKey___lt__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWKey *arg1 = 0 ;
  sword::SWKey *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SWKey___lt__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWKey, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWKey___lt__" "', argument " "1"" of type '" "sword::SWKey *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWKey * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_sword__SWKey,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SWKey___lt__" "', argument " "2"" of type '" "sword::SWKey const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SWKey___lt__" "', argument " "2"" of type '" "sword::SWKey const &""'"); 
  }
  arg2 = reinterpret_cast< sword::SWKey * >(argp2);
  {
    try {
      result = (bool)(arg1)->operator <((sword::SWKey const &)*arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SWKey___ge__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWKey *arg1 = 0 ;
  sword::SWKey *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SWKey___ge__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWKey, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWKey___ge__" "', argument " "1"" of type '" "sword::SWKey *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWKey * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_sword__SWKey,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SWKey___ge__" "', argument " "2"" of type '" "sword::SWKey const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SWKey___ge__" "', argument " "2"" of type '" "sword::SWKey const &""'"); 
  }
  arg2 = reinterpret_cast< sword::SWKey * >(argp2);
  {
    try {
      result = (bool)(arg1)->operator >=((sword::SWKey const &)*arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SWKey___le__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWKey *arg1 = 0 ;
  sword::SWKey *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SWKey___le__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWKey, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWKey___le__" "', argument " "1"" of type '" "sword::SWKey *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWKey * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_sword__SWKey,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SWKey___le__" "', argument " "2"" of type '" "sword::SWKey const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SWKey___le__" "', argument " "2"" of type '" "sword::SWKey const &""'"); 
  }
  arg2 = reinterpret_cast< sword::SWKey * >(argp2);
  {
    try {
      result = (bool)(arg1)->operator <=((sword::SWKey const &)*arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SWKey___isub__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWKey *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  sword::SWKey *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SWKey___isub__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWKey, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWKey___isub__" "', argument " "1"" of type '" "sword::SWKey *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWKey * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SWKey___isub__" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    try {
      result = (sword::SWKey *) &(arg1)->operator -=(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__SWKey, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWKey___iadd__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWKey *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  sword::SWKey *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SWKey___iadd__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWKey, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWKey___iadd__" "', argument " "1"" of type '" "sword::SWKey *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWKey * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SWKey___iadd__" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    try {
      result = (sword::SWKey *) &(arg1)->operator +=(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__SWKey, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SWKey_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_sword__SWKey, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SWKey_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_ListKey__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  sword::ListKey *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ListKey" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  {
    try {
      result = (sword::ListKey *)new sword::ListKey((char const *)arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__ListKey, SWIG_POINTER_NEW |  0 );
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ListKey__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  sword::ListKey *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (sword::ListKey *)new sword::ListKey(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__ListKey, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ListKey__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::ListKey *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  sword::ListKey *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_sword__ListKey,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ListKey" "', argument " "1"" of type '" "sword::ListKey const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_ListKey" "', argument " "1"" of type '" "sword::ListKey const &""'"); 
  }
  arg1 = reinterpret_cast< sword::ListKey * >(argp1);
  {
    try {
      result = (sword::ListKey *)new sword::ListKey((sword::ListKey const &)*arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__ListKey, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ListKey(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_ListKey", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_ListKey__SWIG_1(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_sword__ListKey, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ListKey__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ListKey__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_ListKey'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    sword::ListKey::ListKey(char const *)\n"
    "    sword::ListKey::ListKey()\n"
    "    sword::ListKey::ListKey(sword::ListKey const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_ListKey(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::ListKey *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__ListKey, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ListKey" "', argument " "1"" of type '" "sword::ListKey *""'"); 
  }
  arg1 = reinterpret_cast< sword::ListKey * >(argp1);
  {
    try {
      delete arg1; 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ListKey_clone(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::ListKey *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  sword::SWKey *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__ListKey, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListKey_clone" "', argument " "1"" of type '" "sword::ListKey const *""'"); 
  }
  arg1 = reinterpret_cast< sword::ListKey * >(argp1);
  {
    try {
      result = (sword::SWKey *)((sword::ListKey const *)arg1)->clone(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__SWKey, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ListKey_clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::ListKey *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__ListKey, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListKey_clear" "', argument " "1"" of type '" "sword::ListKey *""'"); 
  }
  arg1 = reinterpret_cast< sword::ListKey * >(argp1);
  {
    try {
      (arg1)->clear(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ListKey_getCount(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::ListKey *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__ListKey, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListKey_getCount" "', argument " "1"" of type '" "sword::ListKey const *""'"); 
  }
  arg1 = reinterpret_cast< sword::ListKey * >(argp1);
  {
    try {
      result = (int)((sword::ListKey const *)arg1)->getCount(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ListKey_remove(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::ListKey *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__ListKey, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListKey_remove" "', argument " "1"" of type '" "sword::ListKey *""'"); 
  }
  arg1 = reinterpret_cast< sword::ListKey * >(argp1);
  {
    try {
      (arg1)->remove(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ListKey_setToElement__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::ListKey *arg1 = 0 ;
  int arg2 ;
  SwigValueWrapper< sword::SW_POSITION > arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  char result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__ListKey, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListKey_setToElement" "', argument " "1"" of type '" "sword::ListKey *""'"); 
  }
  arg1 = reinterpret_cast< sword::ListKey * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ListKey_setToElement" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_sword__SW_POSITION,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ListKey_setToElement" "', argument " "3"" of type '" "sword::SW_POSITION""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "ListKey_setToElement" "', argument " "3"" of type '" "sword::SW_POSITION""'");
    } else {
      sword::SW_POSITION * temp = reinterpret_cast< sword::SW_POSITION * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  {
    try {
      result = (char)(arg1)->setToElement(arg2,SWIG_STD_MOVE(arg3)); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_char(static_cast< char >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ListKey_setToElement__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::ListKey *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  char result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__ListKey, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListKey_setToElement" "', argument " "1"" of type '" "sword::ListKey *""'"); 
  }
  arg1 = reinterpret_cast< sword::ListKey * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ListKey_setToElement" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    try {
      result = (char)(arg1)->setToElement(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_char(static_cast< char >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ListKey_setToElement(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "ListKey_setToElement", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__ListKey, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_ListKey_setToElement__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__ListKey, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_sword__SW_POSITION, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_ListKey_setToElement__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ListKey_setToElement'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    sword::ListKey::setToElement(int,sword::SW_POSITION)\n"
    "    sword::ListKey::setToElement(int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ListKey_getElement__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::ListKey *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  sword::SWKey *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__ListKey, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListKey_getElement" "', argument " "1"" of type '" "sword::ListKey *""'"); 
  }
  arg1 = reinterpret_cast< sword::ListKey * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ListKey_getElement" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    try {
      result = (sword::SWKey *)(arg1)->getElement(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__SWKey, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ListKey_getElement__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::ListKey *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  sword::SWKey *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__ListKey, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListKey_getElement" "', argument " "1"" of type '" "sword::ListKey *""'"); 
  }
  arg1 = reinterpret_cast< sword::ListKey * >(argp1);
  {
    try {
      result = (sword::SWKey *)(arg1)->getElement(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__SWKey, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ListKey_getElement__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::ListKey *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  sword::SWKey *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__ListKey, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListKey_getElement" "', argument " "1"" of type '" "sword::ListKey const *""'"); 
  }
  arg1 = reinterpret_cast< sword::ListKey * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ListKey_getElement" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    try {
      result = (sword::SWKey *)((sword::ListKey const *)arg1)->getElement(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__SWKey, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ListKey_getElement__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::ListKey *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  sword::SWKey *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__ListKey, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListKey_getElement" "', argument " "1"" of type '" "sword::ListKey const *""'"); 
  }
  arg1 = reinterpret_cast< sword::ListKey * >(argp1);
  {
    try {
      result = (sword::SWKey *)((sword::ListKey const *)arg1)->getElement(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__SWKey, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ListKey_getElement(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "ListKey_getElement", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__ListKey, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_ListKey_getElement__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__ListKey, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_ListKey_getElement__SWIG_3(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__ListKey, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_ListKey_getElement__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__ListKey, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_ListKey_getElement__SWIG_2(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ListKey_getElement'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    sword::ListKey::getElement(int)\n"
    "    sword::ListKey::getElement()\n"
    "    sword::ListKey::getElement(int) const\n"
    "    sword::ListKey::getElement() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ListKey_add(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::ListKey *arg1 = 0 ;
  sword::SWKey *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ListKey_add", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__ListKey, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListKey_add" "', argument " "1"" of type '" "sword::ListKey *""'"); 
  }
  arg1 = reinterpret_cast< sword::ListKey * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_sword__SWKey,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ListKey_add" "', argument " "2"" of type '" "sword::SWKey const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "ListKey_add" "', argument " "2"" of type '" "sword::SWKey const &""'"); 
  }
  arg2 = reinterpret_cast< sword::SWKey * >(argp2);
  {
    try {
      (arg1)->add((sword::SWKey const &)*arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ListKey_copyFrom__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::ListKey *arg1 = 0 ;
  sword::ListKey *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__ListKey, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListKey_copyFrom" "', argument " "1"" of type '" "sword::ListKey *""'"); 
  }
  arg1 = reinterpret_cast< sword::ListKey * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_sword__ListKey,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ListKey_copyFrom" "', argument " "2"" of type '" "sword::ListKey const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "ListKey_copyFrom" "', argument " "2"" of type '" "sword::ListKey const &""'"); 
  }
  arg2 = reinterpret_cast< sword::ListKey * >(argp2);
  {
    try {
      (arg1)->copyFrom((sword::ListKey const &)*arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ListKey_copyFrom__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::ListKey *arg1 = 0 ;
  sword::SWKey *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__ListKey, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListKey_copyFrom" "', argument " "1"" of type '" "sword::ListKey *""'"); 
  }
  arg1 = reinterpret_cast< sword::ListKey * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_sword__SWKey,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ListKey_copyFrom" "', argument " "2"" of type '" "sword::SWKey const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "ListKey_copyFrom" "', argument " "2"" of type '" "sword::SWKey const &""'"); 
  }
  arg2 = reinterpret_cast< sword::SWKey * >(argp2);
  {
    try {
      (arg1)->copyFrom((sword::SWKey const &)*arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ListKey_copyFrom(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "ListKey_copyFrom", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__ListKey, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_sword__ListKey, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_ListKey_copyFrom__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__ListKey, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_sword__SWKey, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_ListKey_copyFrom__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ListKey_copyFrom'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    sword::ListKey::copyFrom(sword::ListKey const &)\n"
    "    sword::ListKey::copyFrom(sword::SWKey const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ListKey_setPosition(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::ListKey *arg1 = 0 ;
  SwigValueWrapper< sword::SW_POSITION > arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ListKey_setPosition", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__ListKey, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListKey_setPosition" "', argument " "1"" of type '" "sword::ListKey *""'"); 
  }
  arg1 = reinterpret_cast< sword::ListKey * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_sword__SW_POSITION,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ListKey_setPosition" "', argument " "2"" of type '" "sword::SW_POSITION""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "ListKey_setPosition" "', argument " "2"" of type '" "sword::SW_POSITION""'");
    } else {
      sword::SW_POSITION * temp = reinterpret_cast< sword::SW_POSITION * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    try {
      (arg1)->setPosition(SWIG_STD_MOVE(arg2)); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ListKey_decrement__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::ListKey *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__ListKey, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListKey_decrement" "', argument " "1"" of type '" "sword::ListKey *""'"); 
  }
  arg1 = reinterpret_cast< sword::ListKey * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ListKey_decrement" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    try {
      (arg1)->decrement(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ListKey_decrement__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::ListKey *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__ListKey, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListKey_decrement" "', argument " "1"" of type '" "sword::ListKey *""'"); 
  }
  arg1 = reinterpret_cast< sword::ListKey * >(argp1);
  {
    try {
      (arg1)->decrement(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ListKey_decrement(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "ListKey_decrement", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__ListKey, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_ListKey_decrement__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__ListKey, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_ListKey_decrement__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ListKey_decrement'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    sword::ListKey::decrement(int)\n"
    "    sword::ListKey::decrement()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ListKey_increment__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::ListKey *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__ListKey, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListKey_increment" "', argument " "1"" of type '" "sword::ListKey *""'"); 
  }
  arg1 = reinterpret_cast< sword::ListKey * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ListKey_increment" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    try {
      (arg1)->increment(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ListKey_increment__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::ListKey *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__ListKey, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListKey_increment" "', argument " "1"" of type '" "sword::ListKey *""'"); 
  }
  arg1 = reinterpret_cast< sword::ListKey * >(argp1);
  {
    try {
      (arg1)->increment(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ListKey_increment(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "ListKey_increment", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__ListKey, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_ListKey_increment__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__ListKey, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_ListKey_increment__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ListKey_increment'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    sword::ListKey::increment(int)\n"
    "    sword::ListKey::increment()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ListKey_nextElement(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::ListKey *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__ListKey, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListKey_nextElement" "', argument " "1"" of type '" "sword::ListKey *""'"); 
  }
  arg1 = reinterpret_cast< sword::ListKey * >(argp1);
  {
    try {
      (arg1)->nextElement(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ListKey_isTraversable(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::ListKey *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__ListKey, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListKey_isTraversable" "', argument " "1"" of type '" "sword::ListKey const *""'"); 
  }
  arg1 = reinterpret_cast< sword::ListKey * >(argp1);
  {
    try {
      result = (bool)((sword::ListKey const *)arg1)->isTraversable(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ListKey_getIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::ListKey *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  long result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__ListKey, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListKey_getIndex" "', argument " "1"" of type '" "sword::ListKey const *""'"); 
  }
  arg1 = reinterpret_cast< sword::ListKey * >(argp1);
  {
    try {
      result = (long)((sword::ListKey const *)arg1)->getIndex(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_long(static_cast< long >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ListKey_getRangeText(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::ListKey *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__ListKey, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListKey_getRangeText" "', argument " "1"" of type '" "sword::ListKey const *""'"); 
  }
  arg1 = reinterpret_cast< sword::ListKey * >(argp1);
  {
    try {
      result = (char *)((sword::ListKey const *)arg1)->getRangeText(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ListKey_getOSISRefRangeText(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::ListKey *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__ListKey, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListKey_getOSISRefRangeText" "', argument " "1"" of type '" "sword::ListKey const *""'"); 
  }
  arg1 = reinterpret_cast< sword::ListKey * >(argp1);
  {
    try {
      result = (char *)((sword::ListKey const *)arg1)->getOSISRefRangeText(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ListKey_getShortRangeText(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::ListKey *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__ListKey, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListKey_getShortRangeText" "', argument " "1"" of type '" "sword::ListKey const *""'"); 
  }
  arg1 = reinterpret_cast< sword::ListKey * >(argp1);
  {
    try {
      result = (char *)((sword::ListKey const *)arg1)->getShortRangeText(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ListKey_getShortText(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::ListKey *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__ListKey, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListKey_getShortText" "', argument " "1"" of type '" "sword::ListKey const *""'"); 
  }
  arg1 = reinterpret_cast< sword::ListKey * >(argp1);
  {
    try {
      result = (char *)((sword::ListKey const *)arg1)->getShortText(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ListKey_setIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::ListKey *arg1 = 0 ;
  long arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  long val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ListKey_setIndex", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__ListKey, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListKey_setIndex" "', argument " "1"" of type '" "sword::ListKey *""'"); 
  }
  arg1 = reinterpret_cast< sword::ListKey * >(argp1);
  ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ListKey_setIndex" "', argument " "2"" of type '" "long""'");
  } 
  arg2 = static_cast< long >(val2);
  {
    try {
      (arg1)->setIndex(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ListKey_getText(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::ListKey *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__ListKey, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListKey_getText" "', argument " "1"" of type '" "sword::ListKey const *""'"); 
  }
  arg1 = reinterpret_cast< sword::ListKey * >(argp1);
  {
    try {
      result = (char *)((sword::ListKey const *)arg1)->getText(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ListKey_setText(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::ListKey *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ListKey_setText", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__ListKey, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListKey_setText" "', argument " "1"" of type '" "sword::ListKey *""'"); 
  }
  arg1 = reinterpret_cast< sword::ListKey * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ListKey_setText" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    try {
      (arg1)->setText((char const *)arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ListKey_sort(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::ListKey *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__ListKey, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListKey_sort" "', argument " "1"" of type '" "sword::ListKey *""'"); 
  }
  arg1 = reinterpret_cast< sword::ListKey * >(argp1);
  {
    try {
      (arg1)->sort(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ListKey___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::ListKey *arg1 = 0 ;
  sword::SWKey *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ListKey___eq__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__ListKey, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListKey___eq__" "', argument " "1"" of type '" "sword::ListKey *""'"); 
  }
  arg1 = reinterpret_cast< sword::ListKey * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_sword__SWKey,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ListKey___eq__" "', argument " "2"" of type '" "sword::SWKey const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "ListKey___eq__" "', argument " "2"" of type '" "sword::SWKey const &""'"); 
  }
  arg2 = reinterpret_cast< sword::SWKey * >(argp2);
  {
    try {
      result = (bool)(arg1)->operator ==((sword::SWKey const &)*arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_ListKey___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::ListKey *arg1 = 0 ;
  sword::SWKey *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ListKey___ne__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__ListKey, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListKey___ne__" "', argument " "1"" of type '" "sword::ListKey *""'"); 
  }
  arg1 = reinterpret_cast< sword::ListKey * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_sword__SWKey,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ListKey___ne__" "', argument " "2"" of type '" "sword::SWKey const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "ListKey___ne__" "', argument " "2"" of type '" "sword::SWKey const &""'"); 
  }
  arg2 = reinterpret_cast< sword::SWKey * >(argp2);
  {
    try {
      result = (bool)(arg1)->operator !=((sword::SWKey const &)*arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_ListKey___gt__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::ListKey *arg1 = 0 ;
  sword::SWKey *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ListKey___gt__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__ListKey, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListKey___gt__" "', argument " "1"" of type '" "sword::ListKey *""'"); 
  }
  arg1 = reinterpret_cast< sword::ListKey * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_sword__SWKey,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ListKey___gt__" "', argument " "2"" of type '" "sword::SWKey const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "ListKey___gt__" "', argument " "2"" of type '" "sword::SWKey const &""'"); 
  }
  arg2 = reinterpret_cast< sword::SWKey * >(argp2);
  {
    try {
      result = (bool)(arg1)->operator >((sword::SWKey const &)*arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_ListKey___lt__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::ListKey *arg1 = 0 ;
  sword::SWKey *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ListKey___lt__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__ListKey, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListKey___lt__" "', argument " "1"" of type '" "sword::ListKey *""'"); 
  }
  arg1 = reinterpret_cast< sword::ListKey * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_sword__SWKey,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ListKey___lt__" "', argument " "2"" of type '" "sword::SWKey const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "ListKey___lt__" "', argument " "2"" of type '" "sword::SWKey const &""'"); 
  }
  arg2 = reinterpret_cast< sword::SWKey * >(argp2);
  {
    try {
      result = (bool)(arg1)->operator <((sword::SWKey const &)*arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_ListKey___ge__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::ListKey *arg1 = 0 ;
  sword::SWKey *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ListKey___ge__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__ListKey, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListKey___ge__" "', argument " "1"" of type '" "sword::ListKey *""'"); 
  }
  arg1 = reinterpret_cast< sword::ListKey * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_sword__SWKey,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ListKey___ge__" "', argument " "2"" of type '" "sword::SWKey const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "ListKey___ge__" "', argument " "2"" of type '" "sword::SWKey const &""'"); 
  }
  arg2 = reinterpret_cast< sword::SWKey * >(argp2);
  {
    try {
      result = (bool)(arg1)->operator >=((sword::SWKey const &)*arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_ListKey___le__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::ListKey *arg1 = 0 ;
  sword::SWKey *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ListKey___le__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__ListKey, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListKey___le__" "', argument " "1"" of type '" "sword::ListKey *""'"); 
  }
  arg1 = reinterpret_cast< sword::ListKey * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_sword__SWKey,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ListKey___le__" "', argument " "2"" of type '" "sword::SWKey const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "ListKey___le__" "', argument " "2"" of type '" "sword::SWKey const &""'"); 
  }
  arg2 = reinterpret_cast< sword::SWKey * >(argp2);
  {
    try {
      result = (bool)(arg1)->operator <=((sword::SWKey const &)*arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_ListKey___isub__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::ListKey *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  sword::SWKey *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ListKey___isub__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__ListKey, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListKey___isub__" "', argument " "1"" of type '" "sword::ListKey *""'"); 
  }
  arg1 = reinterpret_cast< sword::ListKey * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ListKey___isub__" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    try {
      result = (sword::SWKey *) &(arg1)->operator -=(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__SWKey, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ListKey___iadd__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::ListKey *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  sword::SWKey *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ListKey___iadd__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__ListKey, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListKey___iadd__" "', argument " "1"" of type '" "sword::ListKey *""'"); 
  }
  arg1 = reinterpret_cast< sword::ListKey * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ListKey___iadd__" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    try {
      result = (sword::SWKey *) &(arg1)->operator +=(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__SWKey, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ListKey_castTo(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWKey *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  sword::ListKey *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWKey, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListKey_castTo" "', argument " "1"" of type '" "sword::SWKey *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWKey * >(argp1);
  {
    try {
      result = (sword::ListKey *)sword_ListKey_castTo(arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__ListKey, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ListKey_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_sword__ListKey, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *ListKey_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_VerseKey__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  sword::VerseKey *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VerseKey" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  {
    try {
      result = (sword::VerseKey *)new sword::VerseKey((char const *)arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__VerseKey, SWIG_POINTER_NEW |  0 );
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_VerseKey__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  sword::VerseKey *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (sword::VerseKey *)new sword::VerseKey(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__VerseKey, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_VerseKey__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::SWKey *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  sword::VerseKey *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWKey, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VerseKey" "', argument " "1"" of type '" "sword::SWKey const *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWKey * >(argp1);
  {
    try {
      result = (sword::VerseKey *)new sword::VerseKey((sword::SWKey const *)arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__VerseKey, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_VerseKey__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  char *arg2 = 0 ;
  char *arg3 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  sword::VerseKey *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VerseKey" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_VerseKey" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_VerseKey" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  {
    try {
      result = (sword::VerseKey *)new sword::VerseKey((char const *)arg1,(char const *)arg2,(char const *)arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__VerseKey, SWIG_POINTER_NEW |  0 );
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_VerseKey__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  char *arg2 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  sword::VerseKey *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VerseKey" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_VerseKey" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    try {
      result = (sword::VerseKey *)new sword::VerseKey((char const *)arg1,(char const *)arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__VerseKey, SWIG_POINTER_NEW |  0 );
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_VerseKey__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::VerseKey *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  sword::VerseKey *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_sword__VerseKey,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VerseKey" "', argument " "1"" of type '" "sword::VerseKey const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_VerseKey" "', argument " "1"" of type '" "sword::VerseKey const &""'"); 
  }
  arg1 = reinterpret_cast< sword::VerseKey * >(argp1);
  {
    try {
      result = (sword::VerseKey *)new sword::VerseKey((sword::VerseKey const &)*arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__VerseKey, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_VerseKey(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_VerseKey", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_VerseKey__SWIG_1(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_sword__VerseKey, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_VerseKey__SWIG_5(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__SWKey, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_VerseKey__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_VerseKey__SWIG_0(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_VerseKey__SWIG_4(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_new_VerseKey__SWIG_3(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_VerseKey'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    sword::VerseKey::VerseKey(char const *)\n"
    "    sword::VerseKey::VerseKey()\n"
    "    sword::VerseKey::VerseKey(sword::SWKey const *)\n"
    "    sword::VerseKey::VerseKey(char const *,char const *,char const *)\n"
    "    sword::VerseKey::VerseKey(char const *,char const *)\n"
    "    sword::VerseKey::VerseKey(sword::VerseKey const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_VerseKey(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::VerseKey *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__VerseKey, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VerseKey" "', argument " "1"" of type '" "sword::VerseKey *""'"); 
  }
  arg1 = reinterpret_cast< sword::VerseKey * >(argp1);
  {
    try {
      delete arg1; 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VerseKey_setLowerBound(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::VerseKey *arg1 = 0 ;
  sword::VerseKey *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "VerseKey_setLowerBound", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__VerseKey, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VerseKey_setLowerBound" "', argument " "1"" of type '" "sword::VerseKey *""'"); 
  }
  arg1 = reinterpret_cast< sword::VerseKey * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_sword__VerseKey,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VerseKey_setLowerBound" "', argument " "2"" of type '" "sword::VerseKey const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "VerseKey_setLowerBound" "', argument " "2"" of type '" "sword::VerseKey const &""'"); 
  }
  arg2 = reinterpret_cast< sword::VerseKey * >(argp2);
  {
    try {
      (arg1)->setLowerBound((sword::VerseKey const &)*arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VerseKey_setUpperBound(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::VerseKey *arg1 = 0 ;
  sword::VerseKey *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "VerseKey_setUpperBound", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__VerseKey, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VerseKey_setUpperBound" "', argument " "1"" of type '" "sword::VerseKey *""'"); 
  }
  arg1 = reinterpret_cast< sword::VerseKey * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_sword__VerseKey,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VerseKey_setUpperBound" "', argument " "2"" of type '" "sword::VerseKey const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "VerseKey_setUpperBound" "', argument " "2"" of type '" "sword::VerseKey const &""'"); 
  }
  arg2 = reinterpret_cast< sword::VerseKey * >(argp2);
  {
    try {
      (arg1)->setUpperBound((sword::VerseKey const &)*arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VerseKey_getLowerBound(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::VerseKey *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  sword::VerseKey *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__VerseKey, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VerseKey_getLowerBound" "', argument " "1"" of type '" "sword::VerseKey const *""'"); 
  }
  arg1 = reinterpret_cast< sword::VerseKey * >(argp1);
  {
    try {
      result = (sword::VerseKey *) &((sword::VerseKey const *)arg1)->getLowerBound(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__VerseKey, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VerseKey_getUpperBound(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::VerseKey *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  sword::VerseKey *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__VerseKey, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VerseKey_getUpperBound" "', argument " "1"" of type '" "sword::VerseKey const *""'"); 
  }
  arg1 = reinterpret_cast< sword::VerseKey * >(argp1);
  {
    try {
      result = (sword::VerseKey *) &((sword::VerseKey const *)arg1)->getUpperBound(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__VerseKey, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VerseKey_clearBounds(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::VerseKey *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__VerseKey, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VerseKey_clearBounds" "', argument " "1"" of type '" "sword::VerseKey const *""'"); 
  }
  arg1 = reinterpret_cast< sword::VerseKey * >(argp1);
  {
    try {
      ((sword::VerseKey const *)arg1)->clearBounds(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VerseKey_clone(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::VerseKey *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  sword::SWKey *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__VerseKey, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VerseKey_clone" "', argument " "1"" of type '" "sword::VerseKey const *""'"); 
  }
  arg1 = reinterpret_cast< sword::VerseKey * >(argp1);
  {
    try {
      result = (sword::SWKey *)((sword::VerseKey const *)arg1)->clone(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__SWKey, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VerseKey_getText(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::VerseKey *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__VerseKey, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VerseKey_getText" "', argument " "1"" of type '" "sword::VerseKey const *""'"); 
  }
  arg1 = reinterpret_cast< sword::VerseKey * >(argp1);
  {
    try {
      result = (char *)((sword::VerseKey const *)arg1)->getText(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VerseKey_getShortText(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::VerseKey *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__VerseKey, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VerseKey_getShortText" "', argument " "1"" of type '" "sword::VerseKey const *""'"); 
  }
  arg1 = reinterpret_cast< sword::VerseKey * >(argp1);
  {
    try {
      result = (char *)((sword::VerseKey const *)arg1)->getShortText(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VerseKey_setText__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::VerseKey *arg1 = 0 ;
  char *arg2 = 0 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__VerseKey, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VerseKey_setText" "', argument " "1"" of type '" "sword::VerseKey *""'"); 
  }
  arg1 = reinterpret_cast< sword::VerseKey * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VerseKey_setText" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VerseKey_setText" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    try {
      (arg1)->setText((char const *)arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_VerseKey_setText__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::VerseKey *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__VerseKey, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VerseKey_setText" "', argument " "1"" of type '" "sword::VerseKey *""'"); 
  }
  arg1 = reinterpret_cast< sword::VerseKey * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VerseKey_setText" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    try {
      (arg1)->setText((char const *)arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_VerseKey_setText(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "VerseKey_setText", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__VerseKey, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_VerseKey_setText__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__VerseKey, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_VerseKey_setText__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'VerseKey_setText'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    sword::VerseKey::setText(char const *,bool)\n"
    "    sword::VerseKey::setText(char const *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_VerseKey_copyFrom__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::VerseKey *arg1 = 0 ;
  sword::SWKey *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__VerseKey, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VerseKey_copyFrom" "', argument " "1"" of type '" "sword::VerseKey *""'"); 
  }
  arg1 = reinterpret_cast< sword::VerseKey * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_sword__SWKey,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VerseKey_copyFrom" "', argument " "2"" of type '" "sword::SWKey const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "VerseKey_copyFrom" "', argument " "2"" of type '" "sword::SWKey const &""'"); 
  }
  arg2 = reinterpret_cast< sword::SWKey * >(argp2);
  {
    try {
      (arg1)->copyFrom((sword::SWKey const &)*arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VerseKey_copyFrom__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::VerseKey *arg1 = 0 ;
  sword::VerseKey *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__VerseKey, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VerseKey_copyFrom" "', argument " "1"" of type '" "sword::VerseKey *""'"); 
  }
  arg1 = reinterpret_cast< sword::VerseKey * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_sword__VerseKey,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VerseKey_copyFrom" "', argument " "2"" of type '" "sword::VerseKey const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "VerseKey_copyFrom" "', argument " "2"" of type '" "sword::VerseKey const &""'"); 
  }
  arg2 = reinterpret_cast< sword::VerseKey * >(argp2);
  {
    try {
      (arg1)->copyFrom((sword::VerseKey const &)*arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VerseKey_copyFrom(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "VerseKey_copyFrom", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__VerseKey, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_sword__VerseKey, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_VerseKey_copyFrom__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__VerseKey, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_sword__SWKey, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_VerseKey_copyFrom__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'VerseKey_copyFrom'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    sword::VerseKey::copyFrom(sword::SWKey const &)\n"
    "    sword::VerseKey::copyFrom(sword::VerseKey const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_VerseKey_positionFrom(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::VerseKey *arg1 = 0 ;
  sword::SWKey *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "VerseKey_positionFrom", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__VerseKey, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VerseKey_positionFrom" "', argument " "1"" of type '" "sword::VerseKey *""'"); 
  }
  arg1 = reinterpret_cast< sword::VerseKey * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_sword__SWKey,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VerseKey_positionFrom" "', argument " "2"" of type '" "sword::SWKey const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "VerseKey_positionFrom" "', argument " "2"" of type '" "sword::SWKey const &""'"); 
  }
  arg2 = reinterpret_cast< sword::SWKey * >(argp2);
  {
    try {
      (arg1)->positionFrom((sword::SWKey const &)*arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VerseKey_setPosition(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::VerseKey *arg1 = 0 ;
  SwigValueWrapper< sword::SW_POSITION > arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "VerseKey_setPosition", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__VerseKey, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VerseKey_setPosition" "', argument " "1"" of type '" "sword::VerseKey *""'"); 
  }
  arg1 = reinterpret_cast< sword::VerseKey * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_sword__SW_POSITION,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VerseKey_setPosition" "', argument " "2"" of type '" "sword::SW_POSITION""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "VerseKey_setPosition" "', argument " "2"" of type '" "sword::SW_POSITION""'");
    } else {
      sword::SW_POSITION * temp = reinterpret_cast< sword::SW_POSITION * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    try {
      (arg1)->setPosition(SWIG_STD_MOVE(arg2)); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VerseKey_decrement__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::VerseKey *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__VerseKey, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VerseKey_decrement" "', argument " "1"" of type '" "sword::VerseKey *""'"); 
  }
  arg1 = reinterpret_cast< sword::VerseKey * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VerseKey_decrement" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    try {
      (arg1)->decrement(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VerseKey_decrement__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::VerseKey *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__VerseKey, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VerseKey_decrement" "', argument " "1"" of type '" "sword::VerseKey *""'"); 
  }
  arg1 = reinterpret_cast< sword::VerseKey * >(argp1);
  {
    try {
      (arg1)->decrement(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VerseKey_decrement(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "VerseKey_decrement", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__VerseKey, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_VerseKey_decrement__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__VerseKey, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_VerseKey_decrement__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'VerseKey_decrement'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    sword::VerseKey::decrement(int)\n"
    "    sword::VerseKey::decrement()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_VerseKey_increment__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::VerseKey *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__VerseKey, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VerseKey_increment" "', argument " "1"" of type '" "sword::VerseKey *""'"); 
  }
  arg1 = reinterpret_cast< sword::VerseKey * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VerseKey_increment" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    try {
      (arg1)->increment(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VerseKey_increment__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::VerseKey *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__VerseKey, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VerseKey_increment" "', argument " "1"" of type '" "sword::VerseKey *""'"); 
  }
  arg1 = reinterpret_cast< sword::VerseKey * >(argp1);
  {
    try {
      (arg1)->increment(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VerseKey_increment(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "VerseKey_increment", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__VerseKey, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_VerseKey_increment__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__VerseKey, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_VerseKey_increment__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'VerseKey_increment'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    sword::VerseKey::increment(int)\n"
    "    sword::VerseKey::increment()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_VerseKey_isTraversable(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::VerseKey *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__VerseKey, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VerseKey_isTraversable" "', argument " "1"" of type '" "sword::VerseKey const *""'"); 
  }
  arg1 = reinterpret_cast< sword::VerseKey * >(argp1);
  {
    try {
      result = (bool)((sword::VerseKey const *)arg1)->isTraversable(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VerseKey_getBookName(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::VerseKey *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__VerseKey, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VerseKey_getBookName" "', argument " "1"" of type '" "sword::VerseKey const *""'"); 
  }
  arg1 = reinterpret_cast< sword::VerseKey * >(argp1);
  {
    try {
      result = (char *)((sword::VerseKey const *)arg1)->getBookName(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VerseKey_setBookName(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::VerseKey *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "VerseKey_setBookName", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__VerseKey, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VerseKey_setBookName" "', argument " "1"" of type '" "sword::VerseKey *""'"); 
  }
  arg1 = reinterpret_cast< sword::VerseKey * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VerseKey_setBookName" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    try {
      (arg1)->setBookName((char const *)arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_VerseKey_getBookAbbrev(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::VerseKey *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__VerseKey, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VerseKey_getBookAbbrev" "', argument " "1"" of type '" "sword::VerseKey const *""'"); 
  }
  arg1 = reinterpret_cast< sword::VerseKey * >(argp1);
  {
    try {
      result = (char *)((sword::VerseKey const *)arg1)->getBookAbbrev(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VerseKey_getTestament(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::VerseKey *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__VerseKey, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VerseKey_getTestament" "', argument " "1"" of type '" "sword::VerseKey const *""'"); 
  }
  arg1 = reinterpret_cast< sword::VerseKey * >(argp1);
  {
    try {
      result = (char)((sword::VerseKey const *)arg1)->getTestament(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_char(static_cast< char >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VerseKey_getTestamentMax(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::VerseKey *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__VerseKey, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VerseKey_getTestamentMax" "', argument " "1"" of type '" "sword::VerseKey const *""'"); 
  }
  arg1 = reinterpret_cast< sword::VerseKey * >(argp1);
  {
    try {
      result = (int)((sword::VerseKey const *)arg1)->getTestamentMax(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VerseKey_getBook(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::VerseKey *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__VerseKey, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VerseKey_getBook" "', argument " "1"" of type '" "sword::VerseKey const *""'"); 
  }
  arg1 = reinterpret_cast< sword::VerseKey * >(argp1);
  {
    try {
      result = (char)((sword::VerseKey const *)arg1)->getBook(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_char(static_cast< char >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VerseKey_getBookMax(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::VerseKey *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__VerseKey, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VerseKey_getBookMax" "', argument " "1"" of type '" "sword::VerseKey const *""'"); 
  }
  arg1 = reinterpret_cast< sword::VerseKey * >(argp1);
  {
    try {
      result = (int)((sword::VerseKey const *)arg1)->getBookMax(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VerseKey_getChapter(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::VerseKey *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__VerseKey, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VerseKey_getChapter" "', argument " "1"" of type '" "sword::VerseKey const *""'"); 
  }
  arg1 = reinterpret_cast< sword::VerseKey * >(argp1);
  {
    try {
      result = (int)((sword::VerseKey const *)arg1)->getChapter(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VerseKey_getChapterMax(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::VerseKey *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__VerseKey, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VerseKey_getChapterMax" "', argument " "1"" of type '" "sword::VerseKey const *""'"); 
  }
  arg1 = reinterpret_cast< sword::VerseKey * >(argp1);
  {
    try {
      result = (int)((sword::VerseKey const *)arg1)->getChapterMax(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VerseKey_getVerse(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::VerseKey *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__VerseKey, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VerseKey_getVerse" "', argument " "1"" of type '" "sword::VerseKey const *""'"); 
  }
  arg1 = reinterpret_cast< sword::VerseKey * >(argp1);
  {
    try {
      result = (int)((sword::VerseKey const *)arg1)->getVerse(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VerseKey_getVerseMax(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::VerseKey *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__VerseKey, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VerseKey_getVerseMax" "', argument " "1"" of type '" "sword::VerseKey const *""'"); 
  }
  arg1 = reinterpret_cast< sword::VerseKey * >(argp1);
  {
    try {
      result = (int)((sword::VerseKey const *)arg1)->getVerseMax(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VerseKey_getSuffix(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::VerseKey *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__VerseKey, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VerseKey_getSuffix" "', argument " "1"" of type '" "sword::VerseKey const *""'"); 
  }
  arg1 = reinterpret_cast< sword::VerseKey * >(argp1);
  {
    try {
      result = (char)((sword::VerseKey const *)arg1)->getSuffix(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_char(static_cast< char >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VerseKey_setTestament(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::VerseKey *arg1 = 0 ;
  char arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "VerseKey_setTestament", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__VerseKey, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VerseKey_setTestament" "', argument " "1"" of type '" "sword::VerseKey *""'"); 
  }
  arg1 = reinterpret_cast< sword::VerseKey * >(argp1);
  ecode2 = SWIG_AsVal_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VerseKey_setTestament" "', argument " "2"" of type '" "char""'");
  } 
  arg2 = static_cast< char >(val2);
  {
    try {
      (arg1)->setTestament(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VerseKey_setBook(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::VerseKey *arg1 = 0 ;
  char arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "VerseKey_setBook", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__VerseKey, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VerseKey_setBook" "', argument " "1"" of type '" "sword::VerseKey *""'"); 
  }
  arg1 = reinterpret_cast< sword::VerseKey * >(argp1);
  ecode2 = SWIG_AsVal_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VerseKey_setBook" "', argument " "2"" of type '" "char""'");
  } 
  arg2 = static_cast< char >(val2);
  {
    try {
      (arg1)->setBook(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VerseKey_setChapter(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::VerseKey *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "VerseKey_setChapter", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__VerseKey, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VerseKey_setChapter" "', argument " "1"" of type '" "sword::VerseKey *""'"); 
  }
  arg1 = reinterpret_cast< sword::VerseKey * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VerseKey_setChapter" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    try {
      (arg1)->setChapter(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VerseKey_setVerse(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::VerseKey *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "VerseKey_setVerse", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__VerseKey, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VerseKey_setVerse" "', argument " "1"" of type '" "sword::VerseKey *""'"); 
  }
  arg1 = reinterpret_cast< sword::VerseKey * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VerseKey_setVerse" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    try {
      (arg1)->setVerse(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VerseKey_setSuffix(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::VerseKey *arg1 = 0 ;
  char arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "VerseKey_setSuffix", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__VerseKey, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VerseKey_setSuffix" "', argument " "1"" of type '" "sword::VerseKey *""'"); 
  }
  arg1 = reinterpret_cast< sword::VerseKey * >(argp1);
  ecode2 = SWIG_AsVal_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VerseKey_setSuffix" "', argument " "2"" of type '" "char""'");
  } 
  arg2 = static_cast< char >(val2);
  {
    try {
      (arg1)->setSuffix(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VerseKey_normalize__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::VerseKey *arg1 = 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__VerseKey, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VerseKey_normalize" "', argument " "1"" of type '" "sword::VerseKey *""'"); 
  }
  arg1 = reinterpret_cast< sword::VerseKey * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VerseKey_normalize" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    try {
      (arg1)->normalize(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VerseKey_normalize__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::VerseKey *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__VerseKey, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VerseKey_normalize" "', argument " "1"" of type '" "sword::VerseKey *""'"); 
  }
  arg1 = reinterpret_cast< sword::VerseKey * >(argp1);
  {
    try {
      (arg1)->normalize(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VerseKey_normalize(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "VerseKey_normalize", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__VerseKey, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_VerseKey_normalize__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__VerseKey, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_VerseKey_normalize__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'VerseKey_normalize'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    sword::VerseKey::normalize(bool)\n"
    "    sword::VerseKey::normalize()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_VerseKey_setAutoNormalize(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::VerseKey *arg1 = 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "VerseKey_setAutoNormalize", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__VerseKey, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VerseKey_setAutoNormalize" "', argument " "1"" of type '" "sword::VerseKey *""'"); 
  }
  arg1 = reinterpret_cast< sword::VerseKey * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VerseKey_setAutoNormalize" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    try {
      (arg1)->setAutoNormalize(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VerseKey_isAutoNormalize(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::VerseKey *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__VerseKey, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VerseKey_isAutoNormalize" "', argument " "1"" of type '" "sword::VerseKey const *""'"); 
  }
  arg1 = reinterpret_cast< sword::VerseKey * >(argp1);
  {
    try {
      result = (bool)((sword::VerseKey const *)arg1)->isAutoNormalize(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VerseKey_setIntros(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::VerseKey *arg1 = 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "VerseKey_setIntros", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__VerseKey, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VerseKey_setIntros" "', argument " "1"" of type '" "sword::VerseKey *""'"); 
  }
  arg1 = reinterpret_cast< sword::VerseKey * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VerseKey_setIntros" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    try {
      (arg1)->setIntros(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VerseKey_isIntros(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::VerseKey *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__VerseKey, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VerseKey_isIntros" "', argument " "1"" of type '" "sword::VerseKey const *""'"); 
  }
  arg1 = reinterpret_cast< sword::VerseKey * >(argp1);
  {
    try {
      result = (bool)((sword::VerseKey const *)arg1)->isIntros(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VerseKey_getIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::VerseKey *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  long result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__VerseKey, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VerseKey_getIndex" "', argument " "1"" of type '" "sword::VerseKey const *""'"); 
  }
  arg1 = reinterpret_cast< sword::VerseKey * >(argp1);
  {
    try {
      result = (long)((sword::VerseKey const *)arg1)->getIndex(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_long(static_cast< long >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VerseKey_setIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::VerseKey *arg1 = 0 ;
  long arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  long val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "VerseKey_setIndex", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__VerseKey, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VerseKey_setIndex" "', argument " "1"" of type '" "sword::VerseKey *""'"); 
  }
  arg1 = reinterpret_cast< sword::VerseKey * >(argp1);
  ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VerseKey_setIndex" "', argument " "2"" of type '" "long""'");
  } 
  arg2 = static_cast< long >(val2);
  {
    try {
      (arg1)->setIndex(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VerseKey_getTestamentIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::VerseKey *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  long result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__VerseKey, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VerseKey_getTestamentIndex" "', argument " "1"" of type '" "sword::VerseKey const *""'"); 
  }
  arg1 = reinterpret_cast< sword::VerseKey * >(argp1);
  {
    try {
      result = (long)((sword::VerseKey const *)arg1)->getTestamentIndex(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_long(static_cast< long >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VerseKey_getOSISRef(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::VerseKey *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__VerseKey, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VerseKey_getOSISRef" "', argument " "1"" of type '" "sword::VerseKey const *""'"); 
  }
  arg1 = reinterpret_cast< sword::VerseKey * >(argp1);
  {
    try {
      result = (char *)((sword::VerseKey const *)arg1)->getOSISRef(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VerseKey_getOSISBookName__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::VerseKey *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__VerseKey, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VerseKey_getOSISBookName" "', argument " "1"" of type '" "sword::VerseKey const *""'"); 
  }
  arg1 = reinterpret_cast< sword::VerseKey * >(argp1);
  {
    try {
      result = (char *)((sword::VerseKey const *)arg1)->getOSISBookName(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VerseKey_convertToOSIS(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  sword::SWKey *arg2 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  char *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "VerseKey_convertToOSIS", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VerseKey_convertToOSIS" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_sword__SWKey, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VerseKey_convertToOSIS" "', argument " "2"" of type '" "sword::SWKey const *""'"); 
  }
  arg2 = reinterpret_cast< sword::SWKey * >(argp2);
  {
    try {
      result = (char *)sword::VerseKey::convertToOSIS((char const *)arg1,(sword::SWKey const *)arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_VerseKey_parseVerseList__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::VerseKey *arg1 = 0 ;
  char *arg2 = 0 ;
  char *arg3 = 0 ;
  bool arg4 ;
  bool arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  sword::ListKey result;
  
  (void)self;
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__VerseKey, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VerseKey_parseVerseList" "', argument " "1"" of type '" "sword::VerseKey *""'"); 
  }
  arg1 = reinterpret_cast< sword::VerseKey * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VerseKey_parseVerseList" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VerseKey_parseVerseList" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "VerseKey_parseVerseList" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  ecode5 = SWIG_AsVal_bool(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "VerseKey_parseVerseList" "', argument " "5"" of type '" "bool""'");
  } 
  arg5 = static_cast< bool >(val5);
  {
    try {
      result = (arg1)->parseVerseList((char const *)arg2,(char const *)arg3,arg4,arg5); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj((new sword::ListKey(result)), SWIGTYPE_p_sword__ListKey, SWIG_POINTER_OWN |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_VerseKey_parseVerseList__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::VerseKey *arg1 = 0 ;
  char *arg2 = 0 ;
  char *arg3 = 0 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  sword::ListKey result;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__VerseKey, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VerseKey_parseVerseList" "', argument " "1"" of type '" "sword::VerseKey *""'"); 
  }
  arg1 = reinterpret_cast< sword::VerseKey * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VerseKey_parseVerseList" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VerseKey_parseVerseList" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "VerseKey_parseVerseList" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  {
    try {
      result = (arg1)->parseVerseList((char const *)arg2,(char const *)arg3,arg4); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj((new sword::ListKey(result)), SWIGTYPE_p_sword__ListKey, SWIG_POINTER_OWN |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_VerseKey_parseVerseList__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::VerseKey *arg1 = 0 ;
  char *arg2 = 0 ;
  char *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  sword::ListKey result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__VerseKey, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VerseKey_parseVerseList" "', argument " "1"" of type '" "sword::VerseKey *""'"); 
  }
  arg1 = reinterpret_cast< sword::VerseKey * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VerseKey_parseVerseList" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VerseKey_parseVerseList" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  {
    try {
      result = (arg1)->parseVerseList((char const *)arg2,(char const *)arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj((new sword::ListKey(result)), SWIGTYPE_p_sword__ListKey, SWIG_POINTER_OWN |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_VerseKey_parseVerseList__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::VerseKey *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  sword::ListKey result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__VerseKey, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VerseKey_parseVerseList" "', argument " "1"" of type '" "sword::VerseKey *""'"); 
  }
  arg1 = reinterpret_cast< sword::VerseKey * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VerseKey_parseVerseList" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    try {
      result = (arg1)->parseVerseList((char const *)arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj((new sword::ListKey(result)), SWIGTYPE_p_sword__ListKey, SWIG_POINTER_OWN |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_VerseKey_parseVerseList(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "VerseKey_parseVerseList", 0, 5, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__VerseKey, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_VerseKey_parseVerseList__SWIG_3(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__VerseKey, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_VerseKey_parseVerseList__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__VerseKey, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_VerseKey_parseVerseList__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__VerseKey, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_bool(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_VerseKey_parseVerseList__SWIG_0(self, argc, argv);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'VerseKey_parseVerseList'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    sword::VerseKey::parseVerseList(char const *,char const *,bool,bool)\n"
    "    sword::VerseKey::parseVerseList(char const *,char const *,bool)\n"
    "    sword::VerseKey::parseVerseList(char const *,char const *)\n"
    "    sword::VerseKey::parseVerseList(char const *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_VerseKey_getRangeText(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::VerseKey *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__VerseKey, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VerseKey_getRangeText" "', argument " "1"" of type '" "sword::VerseKey const *""'"); 
  }
  arg1 = reinterpret_cast< sword::VerseKey * >(argp1);
  {
    try {
      result = (char *)((sword::VerseKey const *)arg1)->getRangeText(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VerseKey_getShortRangeText(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::VerseKey *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__VerseKey, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VerseKey_getShortRangeText" "', argument " "1"" of type '" "sword::VerseKey const *""'"); 
  }
  arg1 = reinterpret_cast< sword::VerseKey * >(argp1);
  {
    try {
      result = (char *)((sword::VerseKey const *)arg1)->getShortRangeText(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VerseKey_getOSISRefRangeText(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::VerseKey *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__VerseKey, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VerseKey_getOSISRefRangeText" "', argument " "1"" of type '" "sword::VerseKey const *""'"); 
  }
  arg1 = reinterpret_cast< sword::VerseKey * >(argp1);
  {
    try {
      result = (char *)((sword::VerseKey const *)arg1)->getOSISRefRangeText(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VerseKey_compare(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::VerseKey *arg1 = 0 ;
  sword::SWKey *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "VerseKey_compare", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__VerseKey, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VerseKey_compare" "', argument " "1"" of type '" "sword::VerseKey *""'"); 
  }
  arg1 = reinterpret_cast< sword::VerseKey * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_sword__SWKey,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VerseKey_compare" "', argument " "2"" of type '" "sword::SWKey const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "VerseKey_compare" "', argument " "2"" of type '" "sword::SWKey const &""'"); 
  }
  arg2 = reinterpret_cast< sword::SWKey * >(argp2);
  {
    try {
      result = (int)(arg1)->compare((sword::SWKey const &)*arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VerseKey__compare(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::VerseKey *arg1 = 0 ;
  sword::VerseKey *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "VerseKey__compare", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__VerseKey, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VerseKey__compare" "', argument " "1"" of type '" "sword::VerseKey *""'"); 
  }
  arg1 = reinterpret_cast< sword::VerseKey * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_sword__VerseKey,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VerseKey__compare" "', argument " "2"" of type '" "sword::VerseKey const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "VerseKey__compare" "', argument " "2"" of type '" "sword::VerseKey const &""'"); 
  }
  arg2 = reinterpret_cast< sword::VerseKey * >(argp2);
  {
    try {
      result = (int)(arg1)->_compare((sword::VerseKey const &)*arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VerseKey_setVersificationSystem(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::VerseKey *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "VerseKey_setVersificationSystem", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__VerseKey, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VerseKey_setVersificationSystem" "', argument " "1"" of type '" "sword::VerseKey *""'"); 
  }
  arg1 = reinterpret_cast< sword::VerseKey * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VerseKey_setVersificationSystem" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    try {
      (arg1)->setVersificationSystem((char const *)arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_VerseKey_getVersificationSystem(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::VerseKey *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__VerseKey, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VerseKey_getVersificationSystem" "', argument " "1"" of type '" "sword::VerseKey const *""'"); 
  }
  arg1 = reinterpret_cast< sword::VerseKey * >(argp1);
  {
    try {
      result = (char *)((sword::VerseKey const *)arg1)->getVersificationSystem(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VerseKey_validateCurrentLocale(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::VerseKey *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__VerseKey, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VerseKey_validateCurrentLocale" "', argument " "1"" of type '" "sword::VerseKey const *""'"); 
  }
  arg1 = reinterpret_cast< sword::VerseKey * >(argp1);
  {
    try {
      ((sword::VerseKey const *)arg1)->validateCurrentLocale(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VerseKey___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::VerseKey *arg1 = 0 ;
  sword::SWKey *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "VerseKey___eq__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__VerseKey, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VerseKey___eq__" "', argument " "1"" of type '" "sword::VerseKey *""'"); 
  }
  arg1 = reinterpret_cast< sword::VerseKey * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_sword__SWKey,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VerseKey___eq__" "', argument " "2"" of type '" "sword::SWKey const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "VerseKey___eq__" "', argument " "2"" of type '" "sword::SWKey const &""'"); 
  }
  arg2 = reinterpret_cast< sword::SWKey * >(argp2);
  {
    try {
      result = (bool)(arg1)->operator ==((sword::SWKey const &)*arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_VerseKey___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::VerseKey *arg1 = 0 ;
  sword::SWKey *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "VerseKey___ne__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__VerseKey, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VerseKey___ne__" "', argument " "1"" of type '" "sword::VerseKey *""'"); 
  }
  arg1 = reinterpret_cast< sword::VerseKey * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_sword__SWKey,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VerseKey___ne__" "', argument " "2"" of type '" "sword::SWKey const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "VerseKey___ne__" "', argument " "2"" of type '" "sword::SWKey const &""'"); 
  }
  arg2 = reinterpret_cast< sword::SWKey * >(argp2);
  {
    try {
      result = (bool)(arg1)->operator !=((sword::SWKey const &)*arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_VerseKey___gt__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::VerseKey *arg1 = 0 ;
  sword::SWKey *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "VerseKey___gt__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__VerseKey, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VerseKey___gt__" "', argument " "1"" of type '" "sword::VerseKey *""'"); 
  }
  arg1 = reinterpret_cast< sword::VerseKey * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_sword__SWKey,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VerseKey___gt__" "', argument " "2"" of type '" "sword::SWKey const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "VerseKey___gt__" "', argument " "2"" of type '" "sword::SWKey const &""'"); 
  }
  arg2 = reinterpret_cast< sword::SWKey * >(argp2);
  {
    try {
      result = (bool)(arg1)->operator >((sword::SWKey const &)*arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_VerseKey___lt__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::VerseKey *arg1 = 0 ;
  sword::SWKey *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "VerseKey___lt__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__VerseKey, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VerseKey___lt__" "', argument " "1"" of type '" "sword::VerseKey *""'"); 
  }
  arg1 = reinterpret_cast< sword::VerseKey * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_sword__SWKey,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VerseKey___lt__" "', argument " "2"" of type '" "sword::SWKey const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "VerseKey___lt__" "', argument " "2"" of type '" "sword::SWKey const &""'"); 
  }
  arg2 = reinterpret_cast< sword::SWKey * >(argp2);
  {
    try {
      result = (bool)(arg1)->operator <((sword::SWKey const &)*arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_VerseKey___ge__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::VerseKey *arg1 = 0 ;
  sword::SWKey *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "VerseKey___ge__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__VerseKey, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VerseKey___ge__" "', argument " "1"" of type '" "sword::VerseKey *""'"); 
  }
  arg1 = reinterpret_cast< sword::VerseKey * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_sword__SWKey,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VerseKey___ge__" "', argument " "2"" of type '" "sword::SWKey const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "VerseKey___ge__" "', argument " "2"" of type '" "sword::SWKey const &""'"); 
  }
  arg2 = reinterpret_cast< sword::SWKey * >(argp2);
  {
    try {
      result = (bool)(arg1)->operator >=((sword::SWKey const &)*arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_VerseKey___le__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::VerseKey *arg1 = 0 ;
  sword::SWKey *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "VerseKey___le__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__VerseKey, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VerseKey___le__" "', argument " "1"" of type '" "sword::VerseKey *""'"); 
  }
  arg1 = reinterpret_cast< sword::VerseKey * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_sword__SWKey,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VerseKey___le__" "', argument " "2"" of type '" "sword::SWKey const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "VerseKey___le__" "', argument " "2"" of type '" "sword::SWKey const &""'"); 
  }
  arg2 = reinterpret_cast< sword::SWKey * >(argp2);
  {
    try {
      result = (bool)(arg1)->operator <=((sword::SWKey const &)*arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_VerseKey___isub__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::VerseKey *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  sword::SWKey *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "VerseKey___isub__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__VerseKey, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VerseKey___isub__" "', argument " "1"" of type '" "sword::VerseKey *""'"); 
  }
  arg1 = reinterpret_cast< sword::VerseKey * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VerseKey___isub__" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    try {
      result = (sword::SWKey *) &(arg1)->operator -=(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__SWKey, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VerseKey___iadd__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::VerseKey *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  sword::SWKey *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "VerseKey___iadd__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__VerseKey, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VerseKey___iadd__" "', argument " "1"" of type '" "sword::VerseKey *""'"); 
  }
  arg1 = reinterpret_cast< sword::VerseKey * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VerseKey___iadd__" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    try {
      result = (sword::SWKey *) &(arg1)->operator +=(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__SWKey, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VerseKey_castTo(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWKey *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  sword::VerseKey *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWKey, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VerseKey_castTo" "', argument " "1"" of type '" "sword::SWKey *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWKey * >(argp1);
  {
    try {
      result = (sword::VerseKey *)sword_VerseKey_castTo(arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__VerseKey, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VerseKey_bookCount(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::VerseKey *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "VerseKey_bookCount", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__VerseKey, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VerseKey_bookCount" "', argument " "1"" of type '" "sword::VerseKey *""'"); 
  }
  arg1 = reinterpret_cast< sword::VerseKey * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VerseKey_bookCount" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    try {
      result = (int)sword_VerseKey_bookCount(arg1,arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VerseKey_getBookCount(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::VerseKey *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__VerseKey, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VerseKey_getBookCount" "', argument " "1"" of type '" "sword::VerseKey *""'"); 
  }
  arg1 = reinterpret_cast< sword::VerseKey * >(argp1);
  {
    try {
      result = (int)sword_VerseKey_getBookCount(arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VerseKey_bookName(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::VerseKey *arg1 = 0 ;
  int arg2 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  char *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "VerseKey_bookName", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__VerseKey, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VerseKey_bookName" "', argument " "1"" of type '" "sword::VerseKey *""'"); 
  }
  arg1 = reinterpret_cast< sword::VerseKey * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VerseKey_bookName" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VerseKey_bookName" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  {
    try {
      result = (char *)sword_VerseKey_bookName(arg1,arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VerseKey_getBookNumberByOSISName(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::VerseKey *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "VerseKey_getBookNumberByOSISName", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__VerseKey, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VerseKey_getBookNumberByOSISName" "', argument " "1"" of type '" "sword::VerseKey *""'"); 
  }
  arg1 = reinterpret_cast< sword::VerseKey * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VerseKey_getBookNumberByOSISName" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    try {
      result = (int)sword_VerseKey_getBookNumberByOSISName(arg1,(char const *)arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_VerseKey_getOSISBookName__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::VerseKey *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  char *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__VerseKey, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VerseKey_getOSISBookName" "', argument " "1"" of type '" "sword::VerseKey *""'"); 
  }
  arg1 = reinterpret_cast< sword::VerseKey * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VerseKey_getOSISBookName" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    try {
      result = (char *)sword_VerseKey_getOSISBookName__SWIG_1(arg1,arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VerseKey_getOSISBookName(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "VerseKey_getOSISBookName", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__VerseKey, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_VerseKey_getOSISBookName__SWIG_0(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__VerseKey, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_VerseKey_getOSISBookName__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'VerseKey_getOSISBookName'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    sword::VerseKey::getOSISBookName() const\n"
    "    sword::VerseKey::getOSISBookName(int const)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_VerseKey_chapterCount(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::VerseKey *arg1 = 0 ;
  int arg2 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "VerseKey_chapterCount", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__VerseKey, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VerseKey_chapterCount" "', argument " "1"" of type '" "sword::VerseKey *""'"); 
  }
  arg1 = reinterpret_cast< sword::VerseKey * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VerseKey_chapterCount" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VerseKey_chapterCount" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  {
    try {
      result = (int)sword_VerseKey_chapterCount(arg1,arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VerseKey_verseCount(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::VerseKey *arg1 = 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  PyObject *swig_obj[4] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "VerseKey_verseCount", 4, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__VerseKey, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VerseKey_verseCount" "', argument " "1"" of type '" "sword::VerseKey *""'"); 
  }
  arg1 = reinterpret_cast< sword::VerseKey * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VerseKey_verseCount" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VerseKey_verseCount" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "VerseKey_verseCount" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  {
    try {
      result = (int)sword_VerseKey_verseCount(arg1,arg2,arg3,arg4); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *VerseKey_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_sword__VerseKey, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *VerseKey_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_abbrev_ab_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::abbrev *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__abbrev, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "abbrev_ab_get" "', argument " "1"" of type '" "sword::abbrev *""'"); 
  }
  arg1 = reinterpret_cast< sword::abbrev * >(argp1);
  result = (char *) ((arg1)->ab);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_abbrev_osis_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::abbrev *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "abbrev_osis_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__abbrev, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "abbrev_osis_set" "', argument " "1"" of type '" "sword::abbrev *""'"); 
  }
  arg1 = reinterpret_cast< sword::abbrev * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "abbrev_osis_set" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  if (arg2) {
    size_t size = strlen(reinterpret_cast< const char * >(reinterpret_cast< const char * >(arg2))) + 1;
    arg1->osis = (char const *)reinterpret_cast< char* >(memcpy(new char[size], arg2, sizeof(char)*(size)));
  } else {
    arg1->osis = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_abbrev_osis_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::abbrev *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__abbrev, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "abbrev_osis_get" "', argument " "1"" of type '" "sword::abbrev *""'"); 
  }
  arg1 = reinterpret_cast< sword::abbrev * >(argp1);
  result = (char *) ((arg1)->osis);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_abbrev_getAbbrevCount(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::abbrev *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__abbrev, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "abbrev_getAbbrevCount" "', argument " "1"" of type '" "sword::abbrev *""'"); 
  }
  arg1 = reinterpret_cast< sword::abbrev * >(argp1);
  {
    try {
      result = (int)sword_abbrev_getAbbrevCount(arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_abbrev_getAbbrevData(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::abbrev *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  sword::abbrev *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "abbrev_getAbbrevData", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__abbrev, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "abbrev_getAbbrevData" "', argument " "1"" of type '" "sword::abbrev *""'"); 
  }
  arg1 = reinterpret_cast< sword::abbrev * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "abbrev_getAbbrevData" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    try {
      result = (sword::abbrev *)sword_abbrev_getAbbrevData(arg1,arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__abbrev, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_abbrev(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::abbrev *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_abbrev", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (sword::abbrev *)new sword::abbrev(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__abbrev, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_abbrev(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::abbrev *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__abbrev, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_abbrev" "', argument " "1"" of type '" "sword::abbrev *""'"); 
  }
  arg1 = reinterpret_cast< sword::abbrev * >(argp1);
  {
    try {
      delete arg1; 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *abbrev_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_sword__abbrev, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *abbrev_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_sbook_name_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::sbook *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__sbook, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "sbook_name_get" "', argument " "1"" of type '" "sword::sbook *""'"); 
  }
  arg1 = reinterpret_cast< sword::sbook * >(argp1);
  result = (char *) ((arg1)->name);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_sbook_osis_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::sbook *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "sbook_osis_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__sbook, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "sbook_osis_set" "', argument " "1"" of type '" "sword::sbook *""'"); 
  }
  arg1 = reinterpret_cast< sword::sbook * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "sbook_osis_set" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  if (arg2) {
    size_t size = strlen(reinterpret_cast< const char * >(reinterpret_cast< const char * >(arg2))) + 1;
    arg1->osis = (char const *)reinterpret_cast< char* >(memcpy(new char[size], arg2, sizeof(char)*(size)));
  } else {
    arg1->osis = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_sbook_osis_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::sbook *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__sbook, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "sbook_osis_get" "', argument " "1"" of type '" "sword::sbook *""'"); 
  }
  arg1 = reinterpret_cast< sword::sbook * >(argp1);
  result = (char *) ((arg1)->osis);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_sbook_prefAbbrev_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::sbook *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__sbook, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "sbook_prefAbbrev_get" "', argument " "1"" of type '" "sword::sbook *""'"); 
  }
  arg1 = reinterpret_cast< sword::sbook * >(argp1);
  result = (char *) ((arg1)->prefAbbrev);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_sbook_chapmax_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::sbook *arg1 = 0 ;
  unsigned char arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "sbook_chapmax_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__sbook, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "sbook_chapmax_set" "', argument " "1"" of type '" "sword::sbook *""'"); 
  }
  arg1 = reinterpret_cast< sword::sbook * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "sbook_chapmax_set" "', argument " "2"" of type '" "unsigned char""'");
  } 
  arg2 = static_cast< unsigned char >(val2);
  if (arg1) (arg1)->chapmax = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_sbook_chapmax_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::sbook *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  unsigned char result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__sbook, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "sbook_chapmax_get" "', argument " "1"" of type '" "sword::sbook *""'"); 
  }
  arg1 = reinterpret_cast< sword::sbook * >(argp1);
  result = (unsigned char) ((arg1)->chapmax);
  resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_sbook_verseMax(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::sbook *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "sbook_verseMax", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__sbook, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "sbook_verseMax" "', argument " "1"" of type '" "sword::sbook *""'"); 
  }
  arg1 = reinterpret_cast< sword::sbook * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "sbook_verseMax" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    try {
      result = (int)sword_sbook_verseMax(arg1,arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_sbook(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::sbook *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_sbook", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (sword::sbook *)new sword::sbook(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__sbook, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_sbook(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::sbook *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__sbook, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_sbook" "', argument " "1"" of type '" "sword::sbook *""'"); 
  }
  arg1 = reinterpret_cast< sword::sbook * >(argp1);
  {
    try {
      delete arg1; 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *sbook_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_sword__sbook, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *sbook_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_VersificationMgr(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::VersificationMgr *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_VersificationMgr", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (sword::VersificationMgr *)new sword::VersificationMgr(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__VersificationMgr, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_VersificationMgr(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::VersificationMgr *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__VersificationMgr, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VersificationMgr" "', argument " "1"" of type '" "sword::VersificationMgr *""'"); 
  }
  arg1 = reinterpret_cast< sword::VersificationMgr * >(argp1);
  {
    try {
      delete arg1; 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VersificationMgr_getSystemVersificationMgr(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::VersificationMgr *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "VersificationMgr_getSystemVersificationMgr", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (sword::VersificationMgr *)sword::VersificationMgr::getSystemVersificationMgr(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__VersificationMgr, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VersificationMgr_setSystemVersificationMgr(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::VersificationMgr *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__VersificationMgr, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VersificationMgr_setSystemVersificationMgr" "', argument " "1"" of type '" "sword::VersificationMgr *""'"); 
  }
  arg1 = reinterpret_cast< sword::VersificationMgr * >(argp1);
  {
    try {
      sword::VersificationMgr::setSystemVersificationMgr(arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VersificationMgr_getVersificationSystems(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::VersificationMgr *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  sword::StringList result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__VersificationMgr, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VersificationMgr_getVersificationSystems" "', argument " "1"" of type '" "sword::VersificationMgr const *""'"); 
  }
  arg1 = reinterpret_cast< sword::VersificationMgr * >(argp1);
  {
    try {
      result = ((sword::VersificationMgr const *)arg1)->getVersificationSystems(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = swig::from(static_cast< std::list< sword::SWBuf,std::allocator< sword::SWBuf > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VersificationMgr_getVersificationSystem(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::VersificationMgr *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  sword::VersificationMgr::System *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "VersificationMgr_getVersificationSystem", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__VersificationMgr, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VersificationMgr_getVersificationSystem" "', argument " "1"" of type '" "sword::VersificationMgr const *""'"); 
  }
  arg1 = reinterpret_cast< sword::VersificationMgr * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VersificationMgr_getVersificationSystem" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    try {
      result = (sword::VersificationMgr::System *)((sword::VersificationMgr const *)arg1)->getVersificationSystem((char const *)arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__VersificationMgr__System, 0 |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_VersificationMgr_registerVersificationSystem__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::VersificationMgr *arg1 = 0 ;
  char *arg2 = 0 ;
  sword::sbook *arg3 = 0 ;
  sword::sbook *arg4 = 0 ;
  int *arg5 = 0 ;
  unsigned char *arg6 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  
  (void)self;
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__VersificationMgr, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VersificationMgr_registerVersificationSystem" "', argument " "1"" of type '" "sword::VersificationMgr *""'"); 
  }
  arg1 = reinterpret_cast< sword::VersificationMgr * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VersificationMgr_registerVersificationSystem" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_sword__sbook, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VersificationMgr_registerVersificationSystem" "', argument " "3"" of type '" "sword::sbook const *""'"); 
  }
  arg3 = reinterpret_cast< sword::sbook * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_sword__sbook, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VersificationMgr_registerVersificationSystem" "', argument " "4"" of type '" "sword::sbook const *""'"); 
  }
  arg4 = reinterpret_cast< sword::sbook * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "VersificationMgr_registerVersificationSystem" "', argument " "5"" of type '" "int *""'"); 
  }
  arg5 = reinterpret_cast< int * >(argp5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6,SWIGTYPE_p_unsigned_char, 0 |  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "VersificationMgr_registerVersificationSystem" "', argument " "6"" of type '" "unsigned char const *""'"); 
  }
  arg6 = reinterpret_cast< unsigned char * >(argp6);
  {
    try {
      (arg1)->registerVersificationSystem((char const *)arg2,(sword::sbook const *)arg3,(sword::sbook const *)arg4,arg5,(unsigned char const *)arg6); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_VersificationMgr_registerVersificationSystem__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::VersificationMgr *arg1 = 0 ;
  char *arg2 = 0 ;
  sword::sbook *arg3 = 0 ;
  sword::sbook *arg4 = 0 ;
  int *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  
  (void)self;
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__VersificationMgr, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VersificationMgr_registerVersificationSystem" "', argument " "1"" of type '" "sword::VersificationMgr *""'"); 
  }
  arg1 = reinterpret_cast< sword::VersificationMgr * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VersificationMgr_registerVersificationSystem" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_sword__sbook, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VersificationMgr_registerVersificationSystem" "', argument " "3"" of type '" "sword::sbook const *""'"); 
  }
  arg3 = reinterpret_cast< sword::sbook * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_sword__sbook, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VersificationMgr_registerVersificationSystem" "', argument " "4"" of type '" "sword::sbook const *""'"); 
  }
  arg4 = reinterpret_cast< sword::sbook * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "VersificationMgr_registerVersificationSystem" "', argument " "5"" of type '" "int *""'"); 
  }
  arg5 = reinterpret_cast< int * >(argp5);
  {
    try {
      (arg1)->registerVersificationSystem((char const *)arg2,(sword::sbook const *)arg3,(sword::sbook const *)arg4,arg5); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_VersificationMgr_registerVersificationSystem__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::VersificationMgr *arg1 = 0 ;
  char *arg2 = 0 ;
  sword::TreeKey *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__VersificationMgr, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VersificationMgr_registerVersificationSystem" "', argument " "1"" of type '" "sword::VersificationMgr *""'"); 
  }
  arg1 = reinterpret_cast< sword::VersificationMgr * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VersificationMgr_registerVersificationSystem" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_sword__TreeKey, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VersificationMgr_registerVersificationSystem" "', argument " "3"" of type '" "sword::TreeKey const *""'"); 
  }
  arg3 = reinterpret_cast< sword::TreeKey * >(argp3);
  {
    try {
      (arg1)->registerVersificationSystem((char const *)arg2,(sword::TreeKey const *)arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_VersificationMgr_registerVersificationSystem(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[7] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "VersificationMgr_registerVersificationSystem", 0, 6, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__VersificationMgr, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_sword__TreeKey, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_VersificationMgr_registerVersificationSystem__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__VersificationMgr, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_sword__sbook, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_sword__sbook, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_int, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_VersificationMgr_registerVersificationSystem__SWIG_1(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__VersificationMgr, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_sword__sbook, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_sword__sbook, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_int, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_unsigned_char, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                return _wrap_VersificationMgr_registerVersificationSystem__SWIG_0(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'VersificationMgr_registerVersificationSystem'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    sword::VersificationMgr::registerVersificationSystem(char const *,sword::sbook const *,sword::sbook const *,int *,unsigned char const *)\n"
    "    sword::VersificationMgr::registerVersificationSystem(char const *,sword::sbook const *,sword::sbook const *,int *)\n"
    "    sword::VersificationMgr::registerVersificationSystem(char const *,sword::TreeKey const *)\n");
  return 0;
}


SWIGINTERN PyObject *VersificationMgr_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_sword__VersificationMgr, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *VersificationMgr_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN int Swig_var_builtin_abbrevs_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable builtin_abbrevs is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_builtin_abbrevs_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(sword::builtin_abbrevs), SWIGTYPE_p_sword__abbrev,  0 );
  return pyobj;
}


SWIGINTERN PyObject *_wrap_TreeKey_posChangeListener_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::TreeKey *arg1 = 0 ;
  sword::TreeKey::PositionChangeListener *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "TreeKey_posChangeListener_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__TreeKey, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TreeKey_posChangeListener_set" "', argument " "1"" of type '" "sword::TreeKey *""'"); 
  }
  arg1 = reinterpret_cast< sword::TreeKey * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_sword__TreeKey__PositionChangeListener, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TreeKey_posChangeListener_set" "', argument " "2"" of type '" "sword::TreeKey::PositionChangeListener *""'"); 
  }
  arg2 = reinterpret_cast< sword::TreeKey::PositionChangeListener * >(argp2);
  if (arg1) (arg1)->posChangeListener = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TreeKey_posChangeListener_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::TreeKey *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  sword::TreeKey::PositionChangeListener *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__TreeKey, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TreeKey_posChangeListener_get" "', argument " "1"" of type '" "sword::TreeKey *""'"); 
  }
  arg1 = reinterpret_cast< sword::TreeKey * >(argp1);
  result = (sword::TreeKey::PositionChangeListener *) ((arg1)->posChangeListener);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__TreeKey__PositionChangeListener, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TreeKey_setPositionChangeListener(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::TreeKey *arg1 = 0 ;
  sword::TreeKey::PositionChangeListener *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "TreeKey_setPositionChangeListener", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__TreeKey, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TreeKey_setPositionChangeListener" "', argument " "1"" of type '" "sword::TreeKey *""'"); 
  }
  arg1 = reinterpret_cast< sword::TreeKey * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_sword__TreeKey__PositionChangeListener, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TreeKey_setPositionChangeListener" "', argument " "2"" of type '" "sword::TreeKey::PositionChangeListener *""'"); 
  }
  arg2 = reinterpret_cast< sword::TreeKey::PositionChangeListener * >(argp2);
  {
    try {
      (arg1)->setPositionChangeListener(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_TreeKey(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::TreeKey *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__TreeKey, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TreeKey" "', argument " "1"" of type '" "sword::TreeKey *""'"); 
  }
  arg1 = reinterpret_cast< sword::TreeKey * >(argp1);
  {
    try {
      delete arg1; 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TreeKey_getLocalName(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::TreeKey *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__TreeKey, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TreeKey_getLocalName" "', argument " "1"" of type '" "sword::TreeKey *""'"); 
  }
  arg1 = reinterpret_cast< sword::TreeKey * >(argp1);
  {
    try {
      result = (char *)(arg1)->getLocalName(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TreeKey_setLocalName(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::TreeKey *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  char *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "TreeKey_setLocalName", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__TreeKey, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TreeKey_setLocalName" "', argument " "1"" of type '" "sword::TreeKey *""'"); 
  }
  arg1 = reinterpret_cast< sword::TreeKey * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TreeKey_setLocalName" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    try {
      result = (char *)(arg1)->setLocalName((char const *)arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_TreeKey_getLevel(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::TreeKey *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__TreeKey, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TreeKey_getLevel" "', argument " "1"" of type '" "sword::TreeKey *""'"); 
  }
  arg1 = reinterpret_cast< sword::TreeKey * >(argp1);
  {
    try {
      result = (int)(arg1)->getLevel(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TreeKey_getUserData__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::TreeKey *arg1 = 0 ;
  int *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  char *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__TreeKey, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TreeKey_getUserData" "', argument " "1"" of type '" "sword::TreeKey const *""'"); 
  }
  arg1 = reinterpret_cast< sword::TreeKey * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TreeKey_getUserData" "', argument " "2"" of type '" "int *""'"); 
  }
  arg2 = reinterpret_cast< int * >(argp2);
  {
    try {
      result = (char *)((sword::TreeKey const *)arg1)->getUserData(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TreeKey_getUserData__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::TreeKey *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__TreeKey, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TreeKey_getUserData" "', argument " "1"" of type '" "sword::TreeKey const *""'"); 
  }
  arg1 = reinterpret_cast< sword::TreeKey * >(argp1);
  {
    try {
      result = (char *)((sword::TreeKey const *)arg1)->getUserData(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TreeKey_getUserData(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "TreeKey_getUserData", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__TreeKey, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_TreeKey_getUserData__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__TreeKey, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_int, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_TreeKey_getUserData__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'TreeKey_getUserData'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    sword::TreeKey::getUserData(int *) const\n"
    "    sword::TreeKey::getUserData() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_TreeKey_setUserData(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::TreeKey *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "TreeKey_setUserData", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__TreeKey, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TreeKey_setUserData" "', argument " "1"" of type '" "sword::TreeKey *""'"); 
  }
  arg1 = reinterpret_cast< sword::TreeKey * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TreeKey_setUserData" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    try {
      (arg1)->setUserData((char const *)arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_TreeKey_root(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::TreeKey *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__TreeKey, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TreeKey_root" "', argument " "1"" of type '" "sword::TreeKey *""'"); 
  }
  arg1 = reinterpret_cast< sword::TreeKey * >(argp1);
  {
    try {
      (arg1)->root(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TreeKey_parent(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::TreeKey *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__TreeKey, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TreeKey_parent" "', argument " "1"" of type '" "sword::TreeKey *""'"); 
  }
  arg1 = reinterpret_cast< sword::TreeKey * >(argp1);
  {
    try {
      result = (bool)(arg1)->parent(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TreeKey_firstChild(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::TreeKey *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__TreeKey, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TreeKey_firstChild" "', argument " "1"" of type '" "sword::TreeKey *""'"); 
  }
  arg1 = reinterpret_cast< sword::TreeKey * >(argp1);
  {
    try {
      result = (bool)(arg1)->firstChild(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TreeKey_nextSibling(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::TreeKey *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__TreeKey, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TreeKey_nextSibling" "', argument " "1"" of type '" "sword::TreeKey *""'"); 
  }
  arg1 = reinterpret_cast< sword::TreeKey * >(argp1);
  {
    try {
      result = (bool)(arg1)->nextSibling(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TreeKey_previousSibling(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::TreeKey *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__TreeKey, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TreeKey_previousSibling" "', argument " "1"" of type '" "sword::TreeKey *""'"); 
  }
  arg1 = reinterpret_cast< sword::TreeKey * >(argp1);
  {
    try {
      result = (bool)(arg1)->previousSibling(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TreeKey_hasChildren(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::TreeKey *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__TreeKey, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TreeKey_hasChildren" "', argument " "1"" of type '" "sword::TreeKey *""'"); 
  }
  arg1 = reinterpret_cast< sword::TreeKey * >(argp1);
  {
    try {
      result = (bool)(arg1)->hasChildren(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TreeKey_append(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::TreeKey *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__TreeKey, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TreeKey_append" "', argument " "1"" of type '" "sword::TreeKey *""'"); 
  }
  arg1 = reinterpret_cast< sword::TreeKey * >(argp1);
  {
    try {
      (arg1)->append(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TreeKey_appendChild(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::TreeKey *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__TreeKey, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TreeKey_appendChild" "', argument " "1"" of type '" "sword::TreeKey *""'"); 
  }
  arg1 = reinterpret_cast< sword::TreeKey * >(argp1);
  {
    try {
      (arg1)->appendChild(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TreeKey_insertBefore(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::TreeKey *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__TreeKey, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TreeKey_insertBefore" "', argument " "1"" of type '" "sword::TreeKey *""'"); 
  }
  arg1 = reinterpret_cast< sword::TreeKey * >(argp1);
  {
    try {
      (arg1)->insertBefore(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TreeKey_remove(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::TreeKey *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__TreeKey, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TreeKey_remove" "', argument " "1"" of type '" "sword::TreeKey *""'"); 
  }
  arg1 = reinterpret_cast< sword::TreeKey * >(argp1);
  {
    try {
      (arg1)->remove(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TreeKey_setOffset(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::TreeKey *arg1 = 0 ;
  unsigned long arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "TreeKey_setOffset", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__TreeKey, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TreeKey_setOffset" "', argument " "1"" of type '" "sword::TreeKey *""'"); 
  }
  arg1 = reinterpret_cast< sword::TreeKey * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TreeKey_setOffset" "', argument " "2"" of type '" "unsigned long""'");
  } 
  arg2 = static_cast< unsigned long >(val2);
  {
    try {
      (arg1)->setOffset(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TreeKey_getOffset(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::TreeKey *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  unsigned long result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__TreeKey, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TreeKey_getOffset" "', argument " "1"" of type '" "sword::TreeKey const *""'"); 
  }
  arg1 = reinterpret_cast< sword::TreeKey * >(argp1);
  {
    try {
      result = (unsigned long)((sword::TreeKey const *)arg1)->getOffset(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TreeKey_setText(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::TreeKey *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "TreeKey_setText", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__TreeKey, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TreeKey_setText" "', argument " "1"" of type '" "sword::TreeKey *""'"); 
  }
  arg1 = reinterpret_cast< sword::TreeKey * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TreeKey_setText" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    try {
      (arg1)->setText((char const *)arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_TreeKey_setPosition(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::TreeKey *arg1 = 0 ;
  SwigValueWrapper< sword::SW_POSITION > arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "TreeKey_setPosition", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__TreeKey, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TreeKey_setPosition" "', argument " "1"" of type '" "sword::TreeKey *""'"); 
  }
  arg1 = reinterpret_cast< sword::TreeKey * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_sword__SW_POSITION,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TreeKey_setPosition" "', argument " "2"" of type '" "sword::SW_POSITION""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "TreeKey_setPosition" "', argument " "2"" of type '" "sword::SW_POSITION""'");
    } else {
      sword::SW_POSITION * temp = reinterpret_cast< sword::SW_POSITION * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    try {
      (arg1)->setPosition(SWIG_STD_MOVE(arg2)); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TreeKey_getText(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::TreeKey *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__TreeKey, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TreeKey_getText" "', argument " "1"" of type '" "sword::TreeKey const *""'"); 
  }
  arg1 = reinterpret_cast< sword::TreeKey * >(argp1);
  {
    try {
      result = (char *)((sword::TreeKey const *)arg1)->getText(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TreeKey_compare(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::TreeKey *arg1 = 0 ;
  sword::SWKey *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "TreeKey_compare", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__TreeKey, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TreeKey_compare" "', argument " "1"" of type '" "sword::TreeKey *""'"); 
  }
  arg1 = reinterpret_cast< sword::TreeKey * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_sword__SWKey,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TreeKey_compare" "', argument " "2"" of type '" "sword::SWKey const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "TreeKey_compare" "', argument " "2"" of type '" "sword::SWKey const &""'"); 
  }
  arg2 = reinterpret_cast< sword::SWKey * >(argp2);
  {
    try {
      result = (int)(arg1)->compare((sword::SWKey const &)*arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TreeKey_decrement__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::TreeKey *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__TreeKey, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TreeKey_decrement" "', argument " "1"" of type '" "sword::TreeKey *""'"); 
  }
  arg1 = reinterpret_cast< sword::TreeKey * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TreeKey_decrement" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    try {
      (arg1)->decrement(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TreeKey_decrement__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::TreeKey *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__TreeKey, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TreeKey_decrement" "', argument " "1"" of type '" "sword::TreeKey *""'"); 
  }
  arg1 = reinterpret_cast< sword::TreeKey * >(argp1);
  {
    try {
      (arg1)->decrement(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TreeKey_decrement(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "TreeKey_decrement", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__TreeKey, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_TreeKey_decrement__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__TreeKey, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_TreeKey_decrement__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'TreeKey_decrement'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    sword::TreeKey::decrement(int)\n"
    "    sword::TreeKey::decrement()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_TreeKey_increment__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::TreeKey *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__TreeKey, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TreeKey_increment" "', argument " "1"" of type '" "sword::TreeKey *""'"); 
  }
  arg1 = reinterpret_cast< sword::TreeKey * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TreeKey_increment" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    try {
      (arg1)->increment(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TreeKey_increment__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::TreeKey *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__TreeKey, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TreeKey_increment" "', argument " "1"" of type '" "sword::TreeKey *""'"); 
  }
  arg1 = reinterpret_cast< sword::TreeKey * >(argp1);
  {
    try {
      (arg1)->increment(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TreeKey_increment(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "TreeKey_increment", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__TreeKey, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_TreeKey_increment__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__TreeKey, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_TreeKey_increment__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'TreeKey_increment'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    sword::TreeKey::increment(int)\n"
    "    sword::TreeKey::increment()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_TreeKey_isTraversable(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::TreeKey *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__TreeKey, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TreeKey_isTraversable" "', argument " "1"" of type '" "sword::TreeKey const *""'"); 
  }
  arg1 = reinterpret_cast< sword::TreeKey * >(argp1);
  {
    try {
      result = (bool)((sword::TreeKey const *)arg1)->isTraversable(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TreeKey_getIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::TreeKey *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  long result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__TreeKey, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TreeKey_getIndex" "', argument " "1"" of type '" "sword::TreeKey const *""'"); 
  }
  arg1 = reinterpret_cast< sword::TreeKey * >(argp1);
  {
    try {
      result = (long)((sword::TreeKey const *)arg1)->getIndex(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_long(static_cast< long >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TreeKey_setIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::TreeKey *arg1 = 0 ;
  long arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  long val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "TreeKey_setIndex", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__TreeKey, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TreeKey_setIndex" "', argument " "1"" of type '" "sword::TreeKey *""'"); 
  }
  arg1 = reinterpret_cast< sword::TreeKey * >(argp1);
  ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TreeKey_setIndex" "', argument " "2"" of type '" "long""'");
  } 
  arg2 = static_cast< long >(val2);
  {
    try {
      (arg1)->setIndex(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TreeKey_assureKeyPath__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::TreeKey *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__TreeKey, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TreeKey_assureKeyPath" "', argument " "1"" of type '" "sword::TreeKey *""'"); 
  }
  arg1 = reinterpret_cast< sword::TreeKey * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TreeKey_assureKeyPath" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    try {
      (arg1)->assureKeyPath((char const *)arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_TreeKey_assureKeyPath__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::TreeKey *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__TreeKey, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TreeKey_assureKeyPath" "', argument " "1"" of type '" "sword::TreeKey *""'"); 
  }
  arg1 = reinterpret_cast< sword::TreeKey * >(argp1);
  {
    try {
      (arg1)->assureKeyPath(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TreeKey_assureKeyPath(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "TreeKey_assureKeyPath", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__TreeKey, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_TreeKey_assureKeyPath__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__TreeKey, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_TreeKey_assureKeyPath__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'TreeKey_assureKeyPath'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    sword::TreeKey::assureKeyPath(char const *)\n"
    "    sword::TreeKey::assureKeyPath()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_TreeKey_save(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::TreeKey *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__TreeKey, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TreeKey_save" "', argument " "1"" of type '" "sword::TreeKey *""'"); 
  }
  arg1 = reinterpret_cast< sword::TreeKey * >(argp1);
  {
    try {
      (arg1)->save(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TreeKey___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::TreeKey *arg1 = 0 ;
  sword::SWKey *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "TreeKey___eq__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__TreeKey, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TreeKey___eq__" "', argument " "1"" of type '" "sword::TreeKey *""'"); 
  }
  arg1 = reinterpret_cast< sword::TreeKey * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_sword__SWKey,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TreeKey___eq__" "', argument " "2"" of type '" "sword::SWKey const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "TreeKey___eq__" "', argument " "2"" of type '" "sword::SWKey const &""'"); 
  }
  arg2 = reinterpret_cast< sword::SWKey * >(argp2);
  {
    try {
      result = (bool)(arg1)->operator ==((sword::SWKey const &)*arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_TreeKey___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::TreeKey *arg1 = 0 ;
  sword::SWKey *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "TreeKey___ne__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__TreeKey, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TreeKey___ne__" "', argument " "1"" of type '" "sword::TreeKey *""'"); 
  }
  arg1 = reinterpret_cast< sword::TreeKey * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_sword__SWKey,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TreeKey___ne__" "', argument " "2"" of type '" "sword::SWKey const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "TreeKey___ne__" "', argument " "2"" of type '" "sword::SWKey const &""'"); 
  }
  arg2 = reinterpret_cast< sword::SWKey * >(argp2);
  {
    try {
      result = (bool)(arg1)->operator !=((sword::SWKey const &)*arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_TreeKey___gt__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::TreeKey *arg1 = 0 ;
  sword::SWKey *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "TreeKey___gt__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__TreeKey, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TreeKey___gt__" "', argument " "1"" of type '" "sword::TreeKey *""'"); 
  }
  arg1 = reinterpret_cast< sword::TreeKey * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_sword__SWKey,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TreeKey___gt__" "', argument " "2"" of type '" "sword::SWKey const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "TreeKey___gt__" "', argument " "2"" of type '" "sword::SWKey const &""'"); 
  }
  arg2 = reinterpret_cast< sword::SWKey * >(argp2);
  {
    try {
      result = (bool)(arg1)->operator >((sword::SWKey const &)*arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_TreeKey___lt__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::TreeKey *arg1 = 0 ;
  sword::SWKey *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "TreeKey___lt__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__TreeKey, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TreeKey___lt__" "', argument " "1"" of type '" "sword::TreeKey *""'"); 
  }
  arg1 = reinterpret_cast< sword::TreeKey * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_sword__SWKey,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TreeKey___lt__" "', argument " "2"" of type '" "sword::SWKey const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "TreeKey___lt__" "', argument " "2"" of type '" "sword::SWKey const &""'"); 
  }
  arg2 = reinterpret_cast< sword::SWKey * >(argp2);
  {
    try {
      result = (bool)(arg1)->operator <((sword::SWKey const &)*arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_TreeKey___ge__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::TreeKey *arg1 = 0 ;
  sword::SWKey *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "TreeKey___ge__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__TreeKey, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TreeKey___ge__" "', argument " "1"" of type '" "sword::TreeKey *""'"); 
  }
  arg1 = reinterpret_cast< sword::TreeKey * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_sword__SWKey,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TreeKey___ge__" "', argument " "2"" of type '" "sword::SWKey const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "TreeKey___ge__" "', argument " "2"" of type '" "sword::SWKey const &""'"); 
  }
  arg2 = reinterpret_cast< sword::SWKey * >(argp2);
  {
    try {
      result = (bool)(arg1)->operator >=((sword::SWKey const &)*arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_TreeKey___le__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::TreeKey *arg1 = 0 ;
  sword::SWKey *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "TreeKey___le__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__TreeKey, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TreeKey___le__" "', argument " "1"" of type '" "sword::TreeKey *""'"); 
  }
  arg1 = reinterpret_cast< sword::TreeKey * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_sword__SWKey,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TreeKey___le__" "', argument " "2"" of type '" "sword::SWKey const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "TreeKey___le__" "', argument " "2"" of type '" "sword::SWKey const &""'"); 
  }
  arg2 = reinterpret_cast< sword::SWKey * >(argp2);
  {
    try {
      result = (bool)(arg1)->operator <=((sword::SWKey const &)*arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_TreeKey___isub__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::TreeKey *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  sword::SWKey *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "TreeKey___isub__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__TreeKey, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TreeKey___isub__" "', argument " "1"" of type '" "sword::TreeKey *""'"); 
  }
  arg1 = reinterpret_cast< sword::TreeKey * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TreeKey___isub__" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    try {
      result = (sword::SWKey *) &(arg1)->operator -=(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__SWKey, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TreeKey___iadd__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::TreeKey *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  sword::SWKey *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "TreeKey___iadd__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__TreeKey, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TreeKey___iadd__" "', argument " "1"" of type '" "sword::TreeKey *""'"); 
  }
  arg1 = reinterpret_cast< sword::TreeKey * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TreeKey___iadd__" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    try {
      result = (sword::SWKey *) &(arg1)->operator +=(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__SWKey, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TreeKey_castTo(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWKey *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  sword::TreeKey *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWKey, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TreeKey_castTo" "', argument " "1"" of type '" "sword::SWKey *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWKey * >(argp1);
  {
    try {
      result = (sword::TreeKey *)sword_TreeKey_castTo(arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__TreeKey, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *TreeKey_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_sword__TreeKey, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_TreeKeyIdx__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::TreeKeyIdx *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  sword::TreeKeyIdx *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_sword__TreeKeyIdx,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TreeKeyIdx" "', argument " "1"" of type '" "sword::TreeKeyIdx const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_TreeKeyIdx" "', argument " "1"" of type '" "sword::TreeKeyIdx const &""'"); 
  }
  arg1 = reinterpret_cast< sword::TreeKeyIdx * >(argp1);
  {
    try {
      result = (sword::TreeKeyIdx *)new sword::TreeKeyIdx((sword::TreeKeyIdx const &)*arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__TreeKeyIdx, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TreeKeyIdx__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  int arg2 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  sword::TreeKeyIdx *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TreeKeyIdx" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_TreeKeyIdx" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    try {
      result = (sword::TreeKeyIdx *)new sword::TreeKeyIdx((char const *)arg1,arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__TreeKeyIdx, SWIG_POINTER_NEW |  0 );
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TreeKeyIdx__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  sword::TreeKeyIdx *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TreeKeyIdx" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  {
    try {
      result = (sword::TreeKeyIdx *)new sword::TreeKeyIdx((char const *)arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__TreeKeyIdx, SWIG_POINTER_NEW |  0 );
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TreeKeyIdx(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_TreeKeyIdx", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_sword__TreeKeyIdx, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_TreeKeyIdx__SWIG_0(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_TreeKeyIdx__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_TreeKeyIdx__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_TreeKeyIdx'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    sword::TreeKeyIdx::TreeKeyIdx(sword::TreeKeyIdx const &)\n"
    "    sword::TreeKeyIdx::TreeKeyIdx(char const *,int)\n"
    "    sword::TreeKeyIdx::TreeKeyIdx(char const *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_TreeKeyIdx(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::TreeKeyIdx *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__TreeKeyIdx, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TreeKeyIdx" "', argument " "1"" of type '" "sword::TreeKeyIdx *""'"); 
  }
  arg1 = reinterpret_cast< sword::TreeKeyIdx * >(argp1);
  {
    try {
      delete arg1; 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TreeKeyIdx_clone(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::TreeKeyIdx *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  sword::SWKey *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__TreeKeyIdx, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TreeKeyIdx_clone" "', argument " "1"" of type '" "sword::TreeKeyIdx const *""'"); 
  }
  arg1 = reinterpret_cast< sword::TreeKeyIdx * >(argp1);
  {
    try {
      result = (sword::SWKey *)((sword::TreeKeyIdx const *)arg1)->clone(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__SWKey, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TreeKeyIdx_getLocalName(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::TreeKeyIdx *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__TreeKeyIdx, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TreeKeyIdx_getLocalName" "', argument " "1"" of type '" "sword::TreeKeyIdx *""'"); 
  }
  arg1 = reinterpret_cast< sword::TreeKeyIdx * >(argp1);
  {
    try {
      result = (char *)(arg1)->getLocalName(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TreeKeyIdx_setLocalName(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::TreeKeyIdx *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  char *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "TreeKeyIdx_setLocalName", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__TreeKeyIdx, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TreeKeyIdx_setLocalName" "', argument " "1"" of type '" "sword::TreeKeyIdx *""'"); 
  }
  arg1 = reinterpret_cast< sword::TreeKeyIdx * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TreeKeyIdx_setLocalName" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    try {
      result = (char *)(arg1)->setLocalName((char const *)arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_TreeKeyIdx_getUserData__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::TreeKeyIdx *arg1 = 0 ;
  int *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  char *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__TreeKeyIdx, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TreeKeyIdx_getUserData" "', argument " "1"" of type '" "sword::TreeKeyIdx const *""'"); 
  }
  arg1 = reinterpret_cast< sword::TreeKeyIdx * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TreeKeyIdx_getUserData" "', argument " "2"" of type '" "int *""'"); 
  }
  arg2 = reinterpret_cast< int * >(argp2);
  {
    try {
      result = (char *)((sword::TreeKeyIdx const *)arg1)->getUserData(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TreeKeyIdx_getUserData__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::TreeKeyIdx *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__TreeKeyIdx, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TreeKeyIdx_getUserData" "', argument " "1"" of type '" "sword::TreeKeyIdx const *""'"); 
  }
  arg1 = reinterpret_cast< sword::TreeKeyIdx * >(argp1);
  {
    try {
      result = (char *)((sword::TreeKeyIdx const *)arg1)->getUserData(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TreeKeyIdx_getUserData(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "TreeKeyIdx_getUserData", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__TreeKeyIdx, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_TreeKeyIdx_getUserData__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__TreeKeyIdx, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_int, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_TreeKeyIdx_getUserData__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'TreeKeyIdx_getUserData'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    sword::TreeKeyIdx::getUserData(int *) const\n"
    "    sword::TreeKeyIdx::getUserData() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_TreeKeyIdx_setUserData(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::TreeKeyIdx *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "TreeKeyIdx_setUserData", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__TreeKeyIdx, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TreeKeyIdx_setUserData" "', argument " "1"" of type '" "sword::TreeKeyIdx *""'"); 
  }
  arg1 = reinterpret_cast< sword::TreeKeyIdx * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TreeKeyIdx_setUserData" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    try {
      (arg1)->setUserData((char const *)arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_TreeKeyIdx_root(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::TreeKeyIdx *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__TreeKeyIdx, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TreeKeyIdx_root" "', argument " "1"" of type '" "sword::TreeKeyIdx *""'"); 
  }
  arg1 = reinterpret_cast< sword::TreeKeyIdx * >(argp1);
  {
    try {
      (arg1)->root(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TreeKeyIdx_parent(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::TreeKeyIdx *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__TreeKeyIdx, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TreeKeyIdx_parent" "', argument " "1"" of type '" "sword::TreeKeyIdx *""'"); 
  }
  arg1 = reinterpret_cast< sword::TreeKeyIdx * >(argp1);
  {
    try {
      result = (bool)(arg1)->parent(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TreeKeyIdx_firstChild(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::TreeKeyIdx *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__TreeKeyIdx, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TreeKeyIdx_firstChild" "', argument " "1"" of type '" "sword::TreeKeyIdx *""'"); 
  }
  arg1 = reinterpret_cast< sword::TreeKeyIdx * >(argp1);
  {
    try {
      result = (bool)(arg1)->firstChild(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TreeKeyIdx_nextSibling(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::TreeKeyIdx *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__TreeKeyIdx, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TreeKeyIdx_nextSibling" "', argument " "1"" of type '" "sword::TreeKeyIdx *""'"); 
  }
  arg1 = reinterpret_cast< sword::TreeKeyIdx * >(argp1);
  {
    try {
      result = (bool)(arg1)->nextSibling(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TreeKeyIdx_previousSibling(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::TreeKeyIdx *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__TreeKeyIdx, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TreeKeyIdx_previousSibling" "', argument " "1"" of type '" "sword::TreeKeyIdx *""'"); 
  }
  arg1 = reinterpret_cast< sword::TreeKeyIdx * >(argp1);
  {
    try {
      result = (bool)(arg1)->previousSibling(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TreeKeyIdx_hasChildren(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::TreeKeyIdx *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__TreeKeyIdx, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TreeKeyIdx_hasChildren" "', argument " "1"" of type '" "sword::TreeKeyIdx *""'"); 
  }
  arg1 = reinterpret_cast< sword::TreeKeyIdx * >(argp1);
  {
    try {
      result = (bool)(arg1)->hasChildren(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TreeKeyIdx_append(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::TreeKeyIdx *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__TreeKeyIdx, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TreeKeyIdx_append" "', argument " "1"" of type '" "sword::TreeKeyIdx *""'"); 
  }
  arg1 = reinterpret_cast< sword::TreeKeyIdx * >(argp1);
  {
    try {
      (arg1)->append(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TreeKeyIdx_appendChild(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::TreeKeyIdx *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__TreeKeyIdx, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TreeKeyIdx_appendChild" "', argument " "1"" of type '" "sword::TreeKeyIdx *""'"); 
  }
  arg1 = reinterpret_cast< sword::TreeKeyIdx * >(argp1);
  {
    try {
      (arg1)->appendChild(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TreeKeyIdx_insertBefore(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::TreeKeyIdx *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__TreeKeyIdx, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TreeKeyIdx_insertBefore" "', argument " "1"" of type '" "sword::TreeKeyIdx *""'"); 
  }
  arg1 = reinterpret_cast< sword::TreeKeyIdx * >(argp1);
  {
    try {
      (arg1)->insertBefore(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TreeKeyIdx_remove(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::TreeKeyIdx *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__TreeKeyIdx, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TreeKeyIdx_remove" "', argument " "1"" of type '" "sword::TreeKeyIdx *""'"); 
  }
  arg1 = reinterpret_cast< sword::TreeKeyIdx * >(argp1);
  {
    try {
      (arg1)->remove(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TreeKeyIdx_save(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::TreeKeyIdx *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__TreeKeyIdx, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TreeKeyIdx_save" "', argument " "1"" of type '" "sword::TreeKeyIdx *""'"); 
  }
  arg1 = reinterpret_cast< sword::TreeKeyIdx * >(argp1);
  {
    try {
      (arg1)->save(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TreeKeyIdx_copyFrom__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::TreeKeyIdx *arg1 = 0 ;
  sword::TreeKeyIdx *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__TreeKeyIdx, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TreeKeyIdx_copyFrom" "', argument " "1"" of type '" "sword::TreeKeyIdx *""'"); 
  }
  arg1 = reinterpret_cast< sword::TreeKeyIdx * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_sword__TreeKeyIdx,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TreeKeyIdx_copyFrom" "', argument " "2"" of type '" "sword::TreeKeyIdx const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "TreeKeyIdx_copyFrom" "', argument " "2"" of type '" "sword::TreeKeyIdx const &""'"); 
  }
  arg2 = reinterpret_cast< sword::TreeKeyIdx * >(argp2);
  {
    try {
      (arg1)->copyFrom((sword::TreeKeyIdx const &)*arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TreeKeyIdx_copyFrom__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::TreeKeyIdx *arg1 = 0 ;
  sword::SWKey *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__TreeKeyIdx, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TreeKeyIdx_copyFrom" "', argument " "1"" of type '" "sword::TreeKeyIdx *""'"); 
  }
  arg1 = reinterpret_cast< sword::TreeKeyIdx * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_sword__SWKey,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TreeKeyIdx_copyFrom" "', argument " "2"" of type '" "sword::SWKey const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "TreeKeyIdx_copyFrom" "', argument " "2"" of type '" "sword::SWKey const &""'"); 
  }
  arg2 = reinterpret_cast< sword::SWKey * >(argp2);
  {
    try {
      (arg1)->copyFrom((sword::SWKey const &)*arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TreeKeyIdx_copyFrom(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "TreeKeyIdx_copyFrom", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__TreeKeyIdx, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_sword__TreeKeyIdx, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_TreeKeyIdx_copyFrom__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__TreeKeyIdx, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_sword__SWKey, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_TreeKeyIdx_copyFrom__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'TreeKeyIdx_copyFrom'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    sword::TreeKeyIdx::copyFrom(sword::TreeKeyIdx const &)\n"
    "    sword::TreeKeyIdx::copyFrom(sword::SWKey const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_TreeKeyIdx_setOffset(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::TreeKeyIdx *arg1 = 0 ;
  unsigned long arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "TreeKeyIdx_setOffset", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__TreeKeyIdx, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TreeKeyIdx_setOffset" "', argument " "1"" of type '" "sword::TreeKeyIdx *""'"); 
  }
  arg1 = reinterpret_cast< sword::TreeKeyIdx * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TreeKeyIdx_setOffset" "', argument " "2"" of type '" "unsigned long""'");
  } 
  arg2 = static_cast< unsigned long >(val2);
  {
    try {
      (arg1)->setOffset(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TreeKeyIdx_getOffset(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::TreeKeyIdx *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  unsigned long result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__TreeKeyIdx, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TreeKeyIdx_getOffset" "', argument " "1"" of type '" "sword::TreeKeyIdx const *""'"); 
  }
  arg1 = reinterpret_cast< sword::TreeKeyIdx * >(argp1);
  {
    try {
      result = (unsigned long)((sword::TreeKeyIdx const *)arg1)->getOffset(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TreeKeyIdx_getLevel(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::TreeKeyIdx *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__TreeKeyIdx, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TreeKeyIdx_getLevel" "', argument " "1"" of type '" "sword::TreeKeyIdx *""'"); 
  }
  arg1 = reinterpret_cast< sword::TreeKeyIdx * >(argp1);
  {
    try {
      result = (int)(arg1)->getLevel(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TreeKeyIdx___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::TreeKeyIdx *arg1 = 0 ;
  sword::SWKey *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "TreeKeyIdx___eq__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__TreeKeyIdx, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TreeKeyIdx___eq__" "', argument " "1"" of type '" "sword::TreeKeyIdx *""'"); 
  }
  arg1 = reinterpret_cast< sword::TreeKeyIdx * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_sword__SWKey,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TreeKeyIdx___eq__" "', argument " "2"" of type '" "sword::SWKey const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "TreeKeyIdx___eq__" "', argument " "2"" of type '" "sword::SWKey const &""'"); 
  }
  arg2 = reinterpret_cast< sword::SWKey * >(argp2);
  {
    try {
      result = (bool)(arg1)->operator ==((sword::SWKey const &)*arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_TreeKeyIdx___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::TreeKeyIdx *arg1 = 0 ;
  sword::SWKey *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "TreeKeyIdx___ne__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__TreeKeyIdx, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TreeKeyIdx___ne__" "', argument " "1"" of type '" "sword::TreeKeyIdx *""'"); 
  }
  arg1 = reinterpret_cast< sword::TreeKeyIdx * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_sword__SWKey,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TreeKeyIdx___ne__" "', argument " "2"" of type '" "sword::SWKey const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "TreeKeyIdx___ne__" "', argument " "2"" of type '" "sword::SWKey const &""'"); 
  }
  arg2 = reinterpret_cast< sword::SWKey * >(argp2);
  {
    try {
      result = (bool)(arg1)->operator !=((sword::SWKey const &)*arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_TreeKeyIdx___gt__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::TreeKeyIdx *arg1 = 0 ;
  sword::SWKey *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "TreeKeyIdx___gt__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__TreeKeyIdx, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TreeKeyIdx___gt__" "', argument " "1"" of type '" "sword::TreeKeyIdx *""'"); 
  }
  arg1 = reinterpret_cast< sword::TreeKeyIdx * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_sword__SWKey,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TreeKeyIdx___gt__" "', argument " "2"" of type '" "sword::SWKey const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "TreeKeyIdx___gt__" "', argument " "2"" of type '" "sword::SWKey const &""'"); 
  }
  arg2 = reinterpret_cast< sword::SWKey * >(argp2);
  {
    try {
      result = (bool)(arg1)->operator >((sword::SWKey const &)*arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_TreeKeyIdx___lt__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::TreeKeyIdx *arg1 = 0 ;
  sword::SWKey *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "TreeKeyIdx___lt__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__TreeKeyIdx, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TreeKeyIdx___lt__" "', argument " "1"" of type '" "sword::TreeKeyIdx *""'"); 
  }
  arg1 = reinterpret_cast< sword::TreeKeyIdx * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_sword__SWKey,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TreeKeyIdx___lt__" "', argument " "2"" of type '" "sword::SWKey const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "TreeKeyIdx___lt__" "', argument " "2"" of type '" "sword::SWKey const &""'"); 
  }
  arg2 = reinterpret_cast< sword::SWKey * >(argp2);
  {
    try {
      result = (bool)(arg1)->operator <((sword::SWKey const &)*arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_TreeKeyIdx___ge__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::TreeKeyIdx *arg1 = 0 ;
  sword::SWKey *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "TreeKeyIdx___ge__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__TreeKeyIdx, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TreeKeyIdx___ge__" "', argument " "1"" of type '" "sword::TreeKeyIdx *""'"); 
  }
  arg1 = reinterpret_cast< sword::TreeKeyIdx * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_sword__SWKey,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TreeKeyIdx___ge__" "', argument " "2"" of type '" "sword::SWKey const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "TreeKeyIdx___ge__" "', argument " "2"" of type '" "sword::SWKey const &""'"); 
  }
  arg2 = reinterpret_cast< sword::SWKey * >(argp2);
  {
    try {
      result = (bool)(arg1)->operator >=((sword::SWKey const &)*arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_TreeKeyIdx___le__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::TreeKeyIdx *arg1 = 0 ;
  sword::SWKey *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "TreeKeyIdx___le__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__TreeKeyIdx, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TreeKeyIdx___le__" "', argument " "1"" of type '" "sword::TreeKeyIdx *""'"); 
  }
  arg1 = reinterpret_cast< sword::TreeKeyIdx * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_sword__SWKey,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TreeKeyIdx___le__" "', argument " "2"" of type '" "sword::SWKey const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "TreeKeyIdx___le__" "', argument " "2"" of type '" "sword::SWKey const &""'"); 
  }
  arg2 = reinterpret_cast< sword::SWKey * >(argp2);
  {
    try {
      result = (bool)(arg1)->operator <=((sword::SWKey const &)*arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_TreeKeyIdx___isub__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::TreeKeyIdx *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  sword::SWKey *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "TreeKeyIdx___isub__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__TreeKeyIdx, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TreeKeyIdx___isub__" "', argument " "1"" of type '" "sword::TreeKeyIdx *""'"); 
  }
  arg1 = reinterpret_cast< sword::TreeKeyIdx * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TreeKeyIdx___isub__" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    try {
      result = (sword::SWKey *) &(arg1)->operator -=(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__SWKey, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TreeKeyIdx___iadd__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::TreeKeyIdx *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  sword::SWKey *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "TreeKeyIdx___iadd__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__TreeKeyIdx, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TreeKeyIdx___iadd__" "', argument " "1"" of type '" "sword::TreeKeyIdx *""'"); 
  }
  arg1 = reinterpret_cast< sword::TreeKeyIdx * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TreeKeyIdx___iadd__" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    try {
      result = (sword::SWKey *) &(arg1)->operator +=(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__SWKey, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TreeKeyIdx_setText(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::TreeKeyIdx *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "TreeKeyIdx_setText", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__TreeKeyIdx, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TreeKeyIdx_setText" "', argument " "1"" of type '" "sword::TreeKeyIdx *""'"); 
  }
  arg1 = reinterpret_cast< sword::TreeKeyIdx * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TreeKeyIdx_setText" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    try {
      (arg1)->setText((char const *)arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_TreeKeyIdx_setPosition(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::TreeKeyIdx *arg1 = 0 ;
  SwigValueWrapper< sword::SW_POSITION > arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "TreeKeyIdx_setPosition", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__TreeKeyIdx, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TreeKeyIdx_setPosition" "', argument " "1"" of type '" "sword::TreeKeyIdx *""'"); 
  }
  arg1 = reinterpret_cast< sword::TreeKeyIdx * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_sword__SW_POSITION,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TreeKeyIdx_setPosition" "', argument " "2"" of type '" "sword::SW_POSITION""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "TreeKeyIdx_setPosition" "', argument " "2"" of type '" "sword::SW_POSITION""'");
    } else {
      sword::SW_POSITION * temp = reinterpret_cast< sword::SW_POSITION * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    try {
      (arg1)->setPosition(SWIG_STD_MOVE(arg2)); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TreeKeyIdx_getText(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::TreeKeyIdx *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__TreeKeyIdx, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TreeKeyIdx_getText" "', argument " "1"" of type '" "sword::TreeKeyIdx const *""'"); 
  }
  arg1 = reinterpret_cast< sword::TreeKeyIdx * >(argp1);
  {
    try {
      result = (char *)((sword::TreeKeyIdx const *)arg1)->getText(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TreeKeyIdx__compare(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::TreeKeyIdx *arg1 = 0 ;
  sword::TreeKeyIdx *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "TreeKeyIdx__compare", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__TreeKeyIdx, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TreeKeyIdx__compare" "', argument " "1"" of type '" "sword::TreeKeyIdx *""'"); 
  }
  arg1 = reinterpret_cast< sword::TreeKeyIdx * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_sword__TreeKeyIdx,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TreeKeyIdx__compare" "', argument " "2"" of type '" "sword::TreeKeyIdx const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "TreeKeyIdx__compare" "', argument " "2"" of type '" "sword::TreeKeyIdx const &""'"); 
  }
  arg2 = reinterpret_cast< sword::TreeKeyIdx * >(argp2);
  {
    try {
      result = (int)(arg1)->_compare((sword::TreeKeyIdx const &)*arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TreeKeyIdx_compare(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::TreeKeyIdx *arg1 = 0 ;
  sword::SWKey *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "TreeKeyIdx_compare", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__TreeKeyIdx, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TreeKeyIdx_compare" "', argument " "1"" of type '" "sword::TreeKeyIdx *""'"); 
  }
  arg1 = reinterpret_cast< sword::TreeKeyIdx * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_sword__SWKey,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TreeKeyIdx_compare" "', argument " "2"" of type '" "sword::SWKey const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "TreeKeyIdx_compare" "', argument " "2"" of type '" "sword::SWKey const &""'"); 
  }
  arg2 = reinterpret_cast< sword::SWKey * >(argp2);
  {
    try {
      result = (int)(arg1)->compare((sword::SWKey const &)*arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TreeKeyIdx_decrement__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::TreeKeyIdx *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__TreeKeyIdx, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TreeKeyIdx_decrement" "', argument " "1"" of type '" "sword::TreeKeyIdx *""'"); 
  }
  arg1 = reinterpret_cast< sword::TreeKeyIdx * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TreeKeyIdx_decrement" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    try {
      (arg1)->decrement(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TreeKeyIdx_decrement__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::TreeKeyIdx *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__TreeKeyIdx, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TreeKeyIdx_decrement" "', argument " "1"" of type '" "sword::TreeKeyIdx *""'"); 
  }
  arg1 = reinterpret_cast< sword::TreeKeyIdx * >(argp1);
  {
    try {
      (arg1)->decrement(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TreeKeyIdx_decrement(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "TreeKeyIdx_decrement", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__TreeKeyIdx, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_TreeKeyIdx_decrement__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__TreeKeyIdx, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_TreeKeyIdx_decrement__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'TreeKeyIdx_decrement'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    sword::TreeKeyIdx::decrement(int)\n"
    "    sword::TreeKeyIdx::decrement()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_TreeKeyIdx_increment__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::TreeKeyIdx *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__TreeKeyIdx, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TreeKeyIdx_increment" "', argument " "1"" of type '" "sword::TreeKeyIdx *""'"); 
  }
  arg1 = reinterpret_cast< sword::TreeKeyIdx * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TreeKeyIdx_increment" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    try {
      (arg1)->increment(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TreeKeyIdx_increment__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::TreeKeyIdx *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__TreeKeyIdx, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TreeKeyIdx_increment" "', argument " "1"" of type '" "sword::TreeKeyIdx *""'"); 
  }
  arg1 = reinterpret_cast< sword::TreeKeyIdx * >(argp1);
  {
    try {
      (arg1)->increment(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TreeKeyIdx_increment(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "TreeKeyIdx_increment", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__TreeKeyIdx, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_TreeKeyIdx_increment__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__TreeKeyIdx, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_TreeKeyIdx_increment__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'TreeKeyIdx_increment'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    sword::TreeKeyIdx::increment(int)\n"
    "    sword::TreeKeyIdx::increment()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_TreeKeyIdx_isTraversable(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::TreeKeyIdx *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__TreeKeyIdx, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TreeKeyIdx_isTraversable" "', argument " "1"" of type '" "sword::TreeKeyIdx const *""'"); 
  }
  arg1 = reinterpret_cast< sword::TreeKeyIdx * >(argp1);
  {
    try {
      result = (bool)((sword::TreeKeyIdx const *)arg1)->isTraversable(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TreeKeyIdx_create(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  PyObject *swig_obj[1] ;
  signed char result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TreeKeyIdx_create" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  {
    try {
      result = (signed char)sword::TreeKeyIdx::create((char const *)arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_signed_SS_char(static_cast< signed char >(result));
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_TreeKeyIdx_castTo(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWKey *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  sword::TreeKeyIdx *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWKey, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TreeKeyIdx_castTo" "', argument " "1"" of type '" "sword::SWKey *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWKey * >(argp1);
  {
    try {
      result = (sword::TreeKeyIdx *)sword_TreeKeyIdx_castTo(arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__TreeKeyIdx, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *TreeKeyIdx_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_sword__TreeKeyIdx, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *TreeKeyIdx_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_VerseTreeKey__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::TreeKey *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  sword::VerseTreeKey *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__TreeKey, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VerseTreeKey" "', argument " "1"" of type '" "sword::TreeKey *""'"); 
  }
  arg1 = reinterpret_cast< sword::TreeKey * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_VerseTreeKey" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    try {
      result = (sword::VerseTreeKey *)new sword::VerseTreeKey(arg1,(char const *)arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__VerseTreeKey, SWIG_POINTER_NEW |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_VerseTreeKey__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::TreeKey *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  sword::VerseTreeKey *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__TreeKey, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VerseTreeKey" "', argument " "1"" of type '" "sword::TreeKey *""'"); 
  }
  arg1 = reinterpret_cast< sword::TreeKey * >(argp1);
  {
    try {
      result = (sword::VerseTreeKey *)new sword::VerseTreeKey(arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__VerseTreeKey, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_VerseTreeKey__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::TreeKey *arg1 = 0 ;
  sword::SWKey *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  sword::VerseTreeKey *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__TreeKey, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VerseTreeKey" "', argument " "1"" of type '" "sword::TreeKey *""'"); 
  }
  arg1 = reinterpret_cast< sword::TreeKey * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_sword__SWKey, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_VerseTreeKey" "', argument " "2"" of type '" "sword::SWKey const *""'"); 
  }
  arg2 = reinterpret_cast< sword::SWKey * >(argp2);
  {
    try {
      result = (sword::VerseTreeKey *)new sword::VerseTreeKey(arg1,(sword::SWKey const *)arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__VerseTreeKey, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_VerseTreeKey__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::TreeKey *arg1 = 0 ;
  char *arg2 = 0 ;
  char *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  sword::VerseTreeKey *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__TreeKey, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VerseTreeKey" "', argument " "1"" of type '" "sword::TreeKey *""'"); 
  }
  arg1 = reinterpret_cast< sword::TreeKey * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_VerseTreeKey" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_VerseTreeKey" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  {
    try {
      result = (sword::VerseTreeKey *)new sword::VerseTreeKey(arg1,(char const *)arg2,(char const *)arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__VerseTreeKey, SWIG_POINTER_NEW |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_VerseTreeKey__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::VerseTreeKey *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  sword::VerseTreeKey *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_sword__VerseTreeKey,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VerseTreeKey" "', argument " "1"" of type '" "sword::VerseTreeKey const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_VerseTreeKey" "', argument " "1"" of type '" "sword::VerseTreeKey const &""'"); 
  }
  arg1 = reinterpret_cast< sword::VerseTreeKey * >(argp1);
  {
    try {
      result = (sword::VerseTreeKey *)new sword::VerseTreeKey((sword::VerseTreeKey const &)*arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__VerseTreeKey, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_VerseTreeKey(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_VerseTreeKey", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__TreeKey, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_VerseTreeKey__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_sword__VerseTreeKey, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_VerseTreeKey__SWIG_4(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__TreeKey, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_sword__SWKey, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_VerseTreeKey__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__TreeKey, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_VerseTreeKey__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__TreeKey, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_new_VerseTreeKey__SWIG_3(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_VerseTreeKey'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    sword::VerseTreeKey::VerseTreeKey(sword::TreeKey *,char const *)\n"
    "    sword::VerseTreeKey::VerseTreeKey(sword::TreeKey *)\n"
    "    sword::VerseTreeKey::VerseTreeKey(sword::TreeKey *,sword::SWKey const *)\n"
    "    sword::VerseTreeKey::VerseTreeKey(sword::TreeKey *,char const *,char const *)\n"
    "    sword::VerseTreeKey::VerseTreeKey(sword::VerseTreeKey const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_VerseTreeKey(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::VerseTreeKey *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__VerseTreeKey, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VerseTreeKey" "', argument " "1"" of type '" "sword::VerseTreeKey *""'"); 
  }
  arg1 = reinterpret_cast< sword::VerseTreeKey * >(argp1);
  {
    try {
      delete arg1; 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VerseTreeKey_clone(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::VerseTreeKey *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  sword::SWKey *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__VerseTreeKey, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VerseTreeKey_clone" "', argument " "1"" of type '" "sword::VerseTreeKey const *""'"); 
  }
  arg1 = reinterpret_cast< sword::VerseTreeKey * >(argp1);
  {
    try {
      result = (sword::SWKey *)((sword::VerseTreeKey const *)arg1)->clone(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__SWKey, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VerseTreeKey_isTraversable(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::VerseTreeKey *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__VerseTreeKey, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VerseTreeKey_isTraversable" "', argument " "1"" of type '" "sword::VerseTreeKey const *""'"); 
  }
  arg1 = reinterpret_cast< sword::VerseTreeKey * >(argp1);
  {
    try {
      result = (bool)((sword::VerseTreeKey const *)arg1)->isTraversable(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VerseTreeKey_getTreeKey__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::VerseTreeKey *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  sword::TreeKey *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__VerseTreeKey, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VerseTreeKey_getTreeKey" "', argument " "1"" of type '" "sword::VerseTreeKey *""'"); 
  }
  arg1 = reinterpret_cast< sword::VerseTreeKey * >(argp1);
  {
    try {
      result = (sword::TreeKey *)(arg1)->getTreeKey(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__TreeKey, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VerseTreeKey_getTreeKey__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::VerseTreeKey *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  sword::TreeKey *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__VerseTreeKey, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VerseTreeKey_getTreeKey" "', argument " "1"" of type '" "sword::VerseTreeKey const *""'"); 
  }
  arg1 = reinterpret_cast< sword::VerseTreeKey * >(argp1);
  {
    try {
      result = (sword::TreeKey *)((sword::VerseTreeKey const *)arg1)->getTreeKey(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__TreeKey, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VerseTreeKey_getTreeKey(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "VerseTreeKey_getTreeKey", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__VerseTreeKey, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_VerseTreeKey_getTreeKey__SWIG_0(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__VerseTreeKey, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_VerseTreeKey_getTreeKey__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'VerseTreeKey_getTreeKey'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    sword::VerseTreeKey::getTreeKey()\n"
    "    sword::VerseTreeKey::getTreeKey() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_VerseTreeKey_positionChanged(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::VerseTreeKey *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__VerseTreeKey, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VerseTreeKey_positionChanged" "', argument " "1"" of type '" "sword::VerseTreeKey *""'"); 
  }
  arg1 = reinterpret_cast< sword::VerseTreeKey * >(argp1);
  {
    try {
      (arg1)->positionChanged(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VerseTreeKey_internalPosChange_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::VerseTreeKey *arg1 = 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "VerseTreeKey_internalPosChange_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__VerseTreeKey, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VerseTreeKey_internalPosChange_set" "', argument " "1"" of type '" "sword::VerseTreeKey *""'"); 
  }
  arg1 = reinterpret_cast< sword::VerseTreeKey * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VerseTreeKey_internalPosChange_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->internalPosChange = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VerseTreeKey_internalPosChange_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::VerseTreeKey *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__VerseTreeKey, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VerseTreeKey_internalPosChange_get" "', argument " "1"" of type '" "sword::VerseTreeKey *""'"); 
  }
  arg1 = reinterpret_cast< sword::VerseTreeKey * >(argp1);
  result = (bool) ((arg1)->internalPosChange);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VerseTreeKey_decrement__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::VerseTreeKey *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__VerseTreeKey, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VerseTreeKey_decrement" "', argument " "1"" of type '" "sword::VerseTreeKey *""'"); 
  }
  arg1 = reinterpret_cast< sword::VerseTreeKey * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VerseTreeKey_decrement" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    try {
      (arg1)->decrement(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VerseTreeKey_decrement__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::VerseTreeKey *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__VerseTreeKey, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VerseTreeKey_decrement" "', argument " "1"" of type '" "sword::VerseTreeKey *""'"); 
  }
  arg1 = reinterpret_cast< sword::VerseTreeKey * >(argp1);
  {
    try {
      (arg1)->decrement(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VerseTreeKey_decrement(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "VerseTreeKey_decrement", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__VerseTreeKey, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_VerseTreeKey_decrement__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__VerseTreeKey, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_VerseTreeKey_decrement__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'VerseTreeKey_decrement'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    sword::VerseTreeKey::decrement(int)\n"
    "    sword::VerseTreeKey::decrement()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_VerseTreeKey_increment__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::VerseTreeKey *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__VerseTreeKey, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VerseTreeKey_increment" "', argument " "1"" of type '" "sword::VerseTreeKey *""'"); 
  }
  arg1 = reinterpret_cast< sword::VerseTreeKey * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VerseTreeKey_increment" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    try {
      (arg1)->increment(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VerseTreeKey_increment__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::VerseTreeKey *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__VerseTreeKey, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VerseTreeKey_increment" "', argument " "1"" of type '" "sword::VerseTreeKey *""'"); 
  }
  arg1 = reinterpret_cast< sword::VerseTreeKey * >(argp1);
  {
    try {
      (arg1)->increment(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VerseTreeKey_increment(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "VerseTreeKey_increment", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__VerseTreeKey, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_VerseTreeKey_increment__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__VerseTreeKey, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_VerseTreeKey_increment__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'VerseTreeKey_increment'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    sword::VerseTreeKey::increment(int)\n"
    "    sword::VerseTreeKey::increment()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_VerseTreeKey_setPosition(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::VerseTreeKey *arg1 = 0 ;
  SwigValueWrapper< sword::SW_POSITION > arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "VerseTreeKey_setPosition", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__VerseTreeKey, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VerseTreeKey_setPosition" "', argument " "1"" of type '" "sword::VerseTreeKey *""'"); 
  }
  arg1 = reinterpret_cast< sword::VerseTreeKey * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_sword__SW_POSITION,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VerseTreeKey_setPosition" "', argument " "2"" of type '" "sword::SW_POSITION""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "VerseTreeKey_setPosition" "', argument " "2"" of type '" "sword::SW_POSITION""'");
    } else {
      sword::SW_POSITION * temp = reinterpret_cast< sword::SW_POSITION * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    try {
      (arg1)->setPosition(SWIG_STD_MOVE(arg2)); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VerseTreeKey_newIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::VerseTreeKey *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  long result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__VerseTreeKey, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VerseTreeKey_newIndex" "', argument " "1"" of type '" "sword::VerseTreeKey const *""'"); 
  }
  arg1 = reinterpret_cast< sword::VerseTreeKey * >(argp1);
  {
    try {
      result = (long)((sword::VerseTreeKey const *)arg1)->newIndex(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_long(static_cast< long >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VerseTreeKey___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::VerseTreeKey *arg1 = 0 ;
  sword::SWKey *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "VerseTreeKey___eq__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__VerseTreeKey, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VerseTreeKey___eq__" "', argument " "1"" of type '" "sword::VerseTreeKey *""'"); 
  }
  arg1 = reinterpret_cast< sword::VerseTreeKey * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_sword__SWKey,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VerseTreeKey___eq__" "', argument " "2"" of type '" "sword::SWKey const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "VerseTreeKey___eq__" "', argument " "2"" of type '" "sword::SWKey const &""'"); 
  }
  arg2 = reinterpret_cast< sword::SWKey * >(argp2);
  {
    try {
      result = (bool)(arg1)->operator ==((sword::SWKey const &)*arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_VerseTreeKey___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::VerseTreeKey *arg1 = 0 ;
  sword::SWKey *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "VerseTreeKey___ne__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__VerseTreeKey, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VerseTreeKey___ne__" "', argument " "1"" of type '" "sword::VerseTreeKey *""'"); 
  }
  arg1 = reinterpret_cast< sword::VerseTreeKey * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_sword__SWKey,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VerseTreeKey___ne__" "', argument " "2"" of type '" "sword::SWKey const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "VerseTreeKey___ne__" "', argument " "2"" of type '" "sword::SWKey const &""'"); 
  }
  arg2 = reinterpret_cast< sword::SWKey * >(argp2);
  {
    try {
      result = (bool)(arg1)->operator !=((sword::SWKey const &)*arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_VerseTreeKey___gt__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::VerseTreeKey *arg1 = 0 ;
  sword::SWKey *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "VerseTreeKey___gt__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__VerseTreeKey, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VerseTreeKey___gt__" "', argument " "1"" of type '" "sword::VerseTreeKey *""'"); 
  }
  arg1 = reinterpret_cast< sword::VerseTreeKey * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_sword__SWKey,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VerseTreeKey___gt__" "', argument " "2"" of type '" "sword::SWKey const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "VerseTreeKey___gt__" "', argument " "2"" of type '" "sword::SWKey const &""'"); 
  }
  arg2 = reinterpret_cast< sword::SWKey * >(argp2);
  {
    try {
      result = (bool)(arg1)->operator >((sword::SWKey const &)*arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_VerseTreeKey___lt__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::VerseTreeKey *arg1 = 0 ;
  sword::SWKey *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "VerseTreeKey___lt__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__VerseTreeKey, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VerseTreeKey___lt__" "', argument " "1"" of type '" "sword::VerseTreeKey *""'"); 
  }
  arg1 = reinterpret_cast< sword::VerseTreeKey * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_sword__SWKey,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VerseTreeKey___lt__" "', argument " "2"" of type '" "sword::SWKey const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "VerseTreeKey___lt__" "', argument " "2"" of type '" "sword::SWKey const &""'"); 
  }
  arg2 = reinterpret_cast< sword::SWKey * >(argp2);
  {
    try {
      result = (bool)(arg1)->operator <((sword::SWKey const &)*arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_VerseTreeKey___ge__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::VerseTreeKey *arg1 = 0 ;
  sword::SWKey *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "VerseTreeKey___ge__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__VerseTreeKey, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VerseTreeKey___ge__" "', argument " "1"" of type '" "sword::VerseTreeKey *""'"); 
  }
  arg1 = reinterpret_cast< sword::VerseTreeKey * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_sword__SWKey,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VerseTreeKey___ge__" "', argument " "2"" of type '" "sword::SWKey const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "VerseTreeKey___ge__" "', argument " "2"" of type '" "sword::SWKey const &""'"); 
  }
  arg2 = reinterpret_cast< sword::SWKey * >(argp2);
  {
    try {
      result = (bool)(arg1)->operator >=((sword::SWKey const &)*arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_VerseTreeKey___le__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::VerseTreeKey *arg1 = 0 ;
  sword::SWKey *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "VerseTreeKey___le__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__VerseTreeKey, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VerseTreeKey___le__" "', argument " "1"" of type '" "sword::VerseTreeKey *""'"); 
  }
  arg1 = reinterpret_cast< sword::VerseTreeKey * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_sword__SWKey,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VerseTreeKey___le__" "', argument " "2"" of type '" "sword::SWKey const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "VerseTreeKey___le__" "', argument " "2"" of type '" "sword::SWKey const &""'"); 
  }
  arg2 = reinterpret_cast< sword::SWKey * >(argp2);
  {
    try {
      result = (bool)(arg1)->operator <=((sword::SWKey const &)*arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_VerseTreeKey___isub__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::VerseTreeKey *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  sword::SWKey *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "VerseTreeKey___isub__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__VerseTreeKey, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VerseTreeKey___isub__" "', argument " "1"" of type '" "sword::VerseTreeKey *""'"); 
  }
  arg1 = reinterpret_cast< sword::VerseTreeKey * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VerseTreeKey___isub__" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    try {
      result = (sword::SWKey *) &(arg1)->operator -=(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__SWKey, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VerseTreeKey___iadd__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::VerseTreeKey *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  sword::SWKey *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "VerseTreeKey___iadd__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__VerseTreeKey, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VerseTreeKey___iadd__" "', argument " "1"" of type '" "sword::VerseTreeKey *""'"); 
  }
  arg1 = reinterpret_cast< sword::VerseTreeKey * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VerseTreeKey___iadd__" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    try {
      result = (sword::SWKey *) &(arg1)->operator +=(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__SWKey, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VerseTreeKey_castTo(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWKey *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  sword::VerseTreeKey *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWKey, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VerseTreeKey_castTo" "', argument " "1"" of type '" "sword::SWKey *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWKey * >(argp1);
  {
    try {
      result = (sword::VerseTreeKey *)sword_VerseTreeKey_castTo(arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__VerseTreeKey, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *VerseTreeKey_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_sword__VerseTreeKey, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *VerseTreeKey_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_delete_SWDisplay(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWDisplay *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWDisplay, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SWDisplay" "', argument " "1"" of type '" "sword::SWDisplay *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWDisplay * >(argp1);
  {
    try {
      delete arg1; 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWDisplay_display(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWDisplay *arg1 = 0 ;
  sword::SWModule *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  char result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SWDisplay_display", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWDisplay, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWDisplay_display" "', argument " "1"" of type '" "sword::SWDisplay *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWDisplay * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_sword__SWModule,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SWDisplay_display" "', argument " "2"" of type '" "sword::SWModule &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SWDisplay_display" "', argument " "2"" of type '" "sword::SWModule &""'"); 
  }
  arg2 = reinterpret_cast< sword::SWModule * >(argp2);
  {
    try {
      result = (char)(arg1)->display(*arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_char(static_cast< char >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SWDisplay_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_sword__SWDisplay, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_delete_SWFilter(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWFilter *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWFilter, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SWFilter" "', argument " "1"" of type '" "sword::SWFilter *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWFilter * >(argp1);
  {
    try {
      delete arg1; 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWFilter_processText__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::SWFilter *arg1 = 0 ;
  sword::SWBuf *arg2 = 0 ;
  sword::SWKey *arg3 = 0 ;
  sword::SWModule *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  char result;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWFilter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWFilter_processText" "', argument " "1"" of type '" "sword::SWFilter *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWFilter * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_sword__SWBuf,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SWFilter_processText" "', argument " "2"" of type '" "sword::SWBuf &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SWFilter_processText" "', argument " "2"" of type '" "sword::SWBuf &""'"); 
  }
  arg2 = reinterpret_cast< sword::SWBuf * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_sword__SWKey, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SWFilter_processText" "', argument " "3"" of type '" "sword::SWKey const *""'"); 
  }
  arg3 = reinterpret_cast< sword::SWKey * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_sword__SWModule, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SWFilter_processText" "', argument " "4"" of type '" "sword::SWModule const *""'"); 
  }
  arg4 = reinterpret_cast< sword::SWModule * >(argp4);
  {
    try {
      result = (char)(arg1)->processText(*arg2,(sword::SWKey const *)arg3,(sword::SWModule const *)arg4); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_char(static_cast< char >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWFilter_processText__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::SWFilter *arg1 = 0 ;
  sword::SWBuf *arg2 = 0 ;
  sword::SWKey *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  char result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWFilter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWFilter_processText" "', argument " "1"" of type '" "sword::SWFilter *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWFilter * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_sword__SWBuf,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SWFilter_processText" "', argument " "2"" of type '" "sword::SWBuf &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SWFilter_processText" "', argument " "2"" of type '" "sword::SWBuf &""'"); 
  }
  arg2 = reinterpret_cast< sword::SWBuf * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_sword__SWKey, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SWFilter_processText" "', argument " "3"" of type '" "sword::SWKey const *""'"); 
  }
  arg3 = reinterpret_cast< sword::SWKey * >(argp3);
  {
    try {
      result = (char)(arg1)->processText(*arg2,(sword::SWKey const *)arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_char(static_cast< char >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWFilter_processText__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::SWFilter *arg1 = 0 ;
  sword::SWBuf *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  char result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWFilter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWFilter_processText" "', argument " "1"" of type '" "sword::SWFilter *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWFilter * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_sword__SWBuf,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SWFilter_processText" "', argument " "2"" of type '" "sword::SWBuf &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SWFilter_processText" "', argument " "2"" of type '" "sword::SWBuf &""'"); 
  }
  arg2 = reinterpret_cast< sword::SWBuf * >(argp2);
  {
    try {
      result = (char)(arg1)->processText(*arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_char(static_cast< char >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWFilter_processText(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SWFilter_processText", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__SWFilter, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_sword__SWBuf, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SWFilter_processText__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__SWFilter, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_sword__SWBuf, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_sword__SWKey, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SWFilter_processText__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__SWFilter, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_sword__SWBuf, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_sword__SWKey, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_sword__SWModule, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_SWFilter_processText__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SWFilter_processText'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    sword::SWFilter::processText(sword::SWBuf &,sword::SWKey const *,sword::SWModule const *)\n"
    "    sword::SWFilter::processText(sword::SWBuf &,sword::SWKey const *)\n"
    "    sword::SWFilter::processText(sword::SWBuf &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SWFilter_getHeader(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWFilter *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWFilter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWFilter_getHeader" "', argument " "1"" of type '" "sword::SWFilter const *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWFilter * >(argp1);
  {
    try {
      result = (char *)((sword::SWFilter const *)arg1)->getHeader(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SWFilter_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_sword__SWFilter, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_delete_SWOptionFilter(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWOptionFilter *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWOptionFilter, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SWOptionFilter" "', argument " "1"" of type '" "sword::SWOptionFilter *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWOptionFilter * >(argp1);
  {
    try {
      delete arg1; 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWOptionFilter_isBoolean(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWOptionFilter *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWOptionFilter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWOptionFilter_isBoolean" "', argument " "1"" of type '" "sword::SWOptionFilter *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWOptionFilter * >(argp1);
  {
    try {
      result = (bool)(arg1)->isBoolean(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWOptionFilter_getOptionName(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWOptionFilter *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWOptionFilter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWOptionFilter_getOptionName" "', argument " "1"" of type '" "sword::SWOptionFilter *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWOptionFilter * >(argp1);
  {
    try {
      result = (char *)(arg1)->getOptionName(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWOptionFilter_getOptionTip(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWOptionFilter *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWOptionFilter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWOptionFilter_getOptionTip" "', argument " "1"" of type '" "sword::SWOptionFilter *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWOptionFilter * >(argp1);
  {
    try {
      result = (char *)(arg1)->getOptionTip(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWOptionFilter_getOptionValue(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWOptionFilter *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWOptionFilter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWOptionFilter_getOptionValue" "', argument " "1"" of type '" "sword::SWOptionFilter *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWOptionFilter * >(argp1);
  {
    try {
      result = (char *)(arg1)->getOptionValue(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWOptionFilter_setOptionValue(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWOptionFilter *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SWOptionFilter_setOptionValue", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWOptionFilter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWOptionFilter_setOptionValue" "', argument " "1"" of type '" "sword::SWOptionFilter *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWOptionFilter * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SWOptionFilter_setOptionValue" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    try {
      (arg1)->setOptionValue((char const *)arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWOptionFilter_castTo(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWFilter *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  sword::SWOptionFilter *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWFilter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWOptionFilter_castTo" "', argument " "1"" of type '" "sword::SWFilter *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWFilter * >(argp1);
  {
    try {
      result = (sword::SWOptionFilter *)sword_SWOptionFilter_castTo(arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__SWOptionFilter, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SWOptionFilter_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_sword__SWOptionFilter, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_SWFilterMgr(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWFilterMgr *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SWFilterMgr", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (sword::SWFilterMgr *)new sword::SWFilterMgr(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__SWFilterMgr, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SWFilterMgr(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWFilterMgr *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWFilterMgr, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SWFilterMgr" "', argument " "1"" of type '" "sword::SWFilterMgr *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWFilterMgr * >(argp1);
  {
    try {
      delete arg1; 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWFilterMgr_setParentMgr(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWFilterMgr *arg1 = 0 ;
  sword::SWMgr *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SWFilterMgr_setParentMgr", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWFilterMgr, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWFilterMgr_setParentMgr" "', argument " "1"" of type '" "sword::SWFilterMgr *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWFilterMgr * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_sword__SWMgr, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SWFilterMgr_setParentMgr" "', argument " "2"" of type '" "sword::SWMgr *""'"); 
  }
  arg2 = reinterpret_cast< sword::SWMgr * >(argp2);
  {
    try {
      (arg1)->setParentMgr(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWFilterMgr_getParentMgr(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWFilterMgr *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  sword::SWMgr *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWFilterMgr, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWFilterMgr_getParentMgr" "', argument " "1"" of type '" "sword::SWFilterMgr *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWFilterMgr * >(argp1);
  {
    try {
      result = (sword::SWMgr *)(arg1)->getParentMgr(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__SWMgr, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWFilterMgr_addGlobalOptions(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWFilterMgr *arg1 = 0 ;
  sword::SWModule *arg2 = 0 ;
  sword::ConfigEntMap *arg3 = 0 ;
  SwigValueWrapper< sword::multimapwithdefault< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > >::iterator > arg4 ;
  SwigValueWrapper< sword::multimapwithdefault< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > >::iterator > arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  void *argp5 ;
  int res5 = 0 ;
  PyObject *swig_obj[5] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SWFilterMgr_addGlobalOptions", 5, 5, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWFilterMgr, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWFilterMgr_addGlobalOptions" "', argument " "1"" of type '" "sword::SWFilterMgr *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWFilterMgr * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_sword__SWModule, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SWFilterMgr_addGlobalOptions" "', argument " "2"" of type '" "sword::SWModule *""'"); 
  }
  arg2 = reinterpret_cast< sword::SWModule * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_sword__multimapwithdefaultT_sword__SWBuf_sword__SWBuf_std__lessT_sword__SWBuf_t_t,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SWFilterMgr_addGlobalOptions" "', argument " "3"" of type '" "sword::ConfigEntMap &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SWFilterMgr_addGlobalOptions" "', argument " "3"" of type '" "sword::ConfigEntMap &""'"); 
  }
  arg3 = reinterpret_cast< sword::ConfigEntMap * >(argp3);
  {
    res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_sword__multimapwithdefaultT_sword__SWBuf_sword__SWBuf_std__lessT_sword__SWBuf_t_t__iterator,  0  | 0);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SWFilterMgr_addGlobalOptions" "', argument " "4"" of type '" "sword::ConfigEntMap::iterator""'"); 
    }  
    if (!argp4) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SWFilterMgr_addGlobalOptions" "', argument " "4"" of type '" "sword::ConfigEntMap::iterator""'");
    } else {
      sword::ConfigEntMap::iterator * temp = reinterpret_cast< sword::ConfigEntMap::iterator * >(argp4);
      arg4 = *temp;
      if (SWIG_IsNewObj(res4)) delete temp;
    }
  }
  {
    res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_sword__multimapwithdefaultT_sword__SWBuf_sword__SWBuf_std__lessT_sword__SWBuf_t_t__iterator,  0  | 0);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "SWFilterMgr_addGlobalOptions" "', argument " "5"" of type '" "sword::ConfigEntMap::iterator""'"); 
    }  
    if (!argp5) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SWFilterMgr_addGlobalOptions" "', argument " "5"" of type '" "sword::ConfigEntMap::iterator""'");
    } else {
      sword::ConfigEntMap::iterator * temp = reinterpret_cast< sword::ConfigEntMap::iterator * >(argp5);
      arg5 = *temp;
      if (SWIG_IsNewObj(res5)) delete temp;
    }
  }
  {
    try {
      (arg1)->addGlobalOptions(arg2,*arg3,SWIG_STD_MOVE(arg4),SWIG_STD_MOVE(arg5)); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWFilterMgr_addLocalOptions(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWFilterMgr *arg1 = 0 ;
  sword::SWModule *arg2 = 0 ;
  sword::ConfigEntMap *arg3 = 0 ;
  SwigValueWrapper< sword::multimapwithdefault< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > >::iterator > arg4 ;
  SwigValueWrapper< sword::multimapwithdefault< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > >::iterator > arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  void *argp5 ;
  int res5 = 0 ;
  PyObject *swig_obj[5] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SWFilterMgr_addLocalOptions", 5, 5, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWFilterMgr, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWFilterMgr_addLocalOptions" "', argument " "1"" of type '" "sword::SWFilterMgr *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWFilterMgr * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_sword__SWModule, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SWFilterMgr_addLocalOptions" "', argument " "2"" of type '" "sword::SWModule *""'"); 
  }
  arg2 = reinterpret_cast< sword::SWModule * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_sword__multimapwithdefaultT_sword__SWBuf_sword__SWBuf_std__lessT_sword__SWBuf_t_t,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SWFilterMgr_addLocalOptions" "', argument " "3"" of type '" "sword::ConfigEntMap &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SWFilterMgr_addLocalOptions" "', argument " "3"" of type '" "sword::ConfigEntMap &""'"); 
  }
  arg3 = reinterpret_cast< sword::ConfigEntMap * >(argp3);
  {
    res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_sword__multimapwithdefaultT_sword__SWBuf_sword__SWBuf_std__lessT_sword__SWBuf_t_t__iterator,  0  | 0);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SWFilterMgr_addLocalOptions" "', argument " "4"" of type '" "sword::ConfigEntMap::iterator""'"); 
    }  
    if (!argp4) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SWFilterMgr_addLocalOptions" "', argument " "4"" of type '" "sword::ConfigEntMap::iterator""'");
    } else {
      sword::ConfigEntMap::iterator * temp = reinterpret_cast< sword::ConfigEntMap::iterator * >(argp4);
      arg4 = *temp;
      if (SWIG_IsNewObj(res4)) delete temp;
    }
  }
  {
    res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_sword__multimapwithdefaultT_sword__SWBuf_sword__SWBuf_std__lessT_sword__SWBuf_t_t__iterator,  0  | 0);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "SWFilterMgr_addLocalOptions" "', argument " "5"" of type '" "sword::ConfigEntMap::iterator""'"); 
    }  
    if (!argp5) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SWFilterMgr_addLocalOptions" "', argument " "5"" of type '" "sword::ConfigEntMap::iterator""'");
    } else {
      sword::ConfigEntMap::iterator * temp = reinterpret_cast< sword::ConfigEntMap::iterator * >(argp5);
      arg5 = *temp;
      if (SWIG_IsNewObj(res5)) delete temp;
    }
  }
  {
    try {
      (arg1)->addLocalOptions(arg2,*arg3,SWIG_STD_MOVE(arg4),SWIG_STD_MOVE(arg5)); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWFilterMgr_addEncodingFilters(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWFilterMgr *arg1 = 0 ;
  sword::SWModule *arg2 = 0 ;
  sword::ConfigEntMap *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SWFilterMgr_addEncodingFilters", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWFilterMgr, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWFilterMgr_addEncodingFilters" "', argument " "1"" of type '" "sword::SWFilterMgr *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWFilterMgr * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_sword__SWModule, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SWFilterMgr_addEncodingFilters" "', argument " "2"" of type '" "sword::SWModule *""'"); 
  }
  arg2 = reinterpret_cast< sword::SWModule * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_sword__multimapwithdefaultT_sword__SWBuf_sword__SWBuf_std__lessT_sword__SWBuf_t_t,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SWFilterMgr_addEncodingFilters" "', argument " "3"" of type '" "sword::ConfigEntMap &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SWFilterMgr_addEncodingFilters" "', argument " "3"" of type '" "sword::ConfigEntMap &""'"); 
  }
  arg3 = reinterpret_cast< sword::ConfigEntMap * >(argp3);
  {
    try {
      (arg1)->addEncodingFilters(arg2,*arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWFilterMgr_addRenderFilters(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWFilterMgr *arg1 = 0 ;
  sword::SWModule *arg2 = 0 ;
  sword::ConfigEntMap *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SWFilterMgr_addRenderFilters", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWFilterMgr, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWFilterMgr_addRenderFilters" "', argument " "1"" of type '" "sword::SWFilterMgr *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWFilterMgr * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_sword__SWModule, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SWFilterMgr_addRenderFilters" "', argument " "2"" of type '" "sword::SWModule *""'"); 
  }
  arg2 = reinterpret_cast< sword::SWModule * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_sword__multimapwithdefaultT_sword__SWBuf_sword__SWBuf_std__lessT_sword__SWBuf_t_t,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SWFilterMgr_addRenderFilters" "', argument " "3"" of type '" "sword::ConfigEntMap &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SWFilterMgr_addRenderFilters" "', argument " "3"" of type '" "sword::ConfigEntMap &""'"); 
  }
  arg3 = reinterpret_cast< sword::ConfigEntMap * >(argp3);
  {
    try {
      (arg1)->addRenderFilters(arg2,*arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWFilterMgr_addStripFilters(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWFilterMgr *arg1 = 0 ;
  sword::SWModule *arg2 = 0 ;
  sword::ConfigEntMap *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SWFilterMgr_addStripFilters", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWFilterMgr, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWFilterMgr_addStripFilters" "', argument " "1"" of type '" "sword::SWFilterMgr *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWFilterMgr * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_sword__SWModule, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SWFilterMgr_addStripFilters" "', argument " "2"" of type '" "sword::SWModule *""'"); 
  }
  arg2 = reinterpret_cast< sword::SWModule * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_sword__multimapwithdefaultT_sword__SWBuf_sword__SWBuf_std__lessT_sword__SWBuf_t_t,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SWFilterMgr_addStripFilters" "', argument " "3"" of type '" "sword::ConfigEntMap &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SWFilterMgr_addStripFilters" "', argument " "3"" of type '" "sword::ConfigEntMap &""'"); 
  }
  arg3 = reinterpret_cast< sword::ConfigEntMap * >(argp3);
  {
    try {
      (arg1)->addStripFilters(arg2,*arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWFilterMgr_addRawFilters(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWFilterMgr *arg1 = 0 ;
  sword::SWModule *arg2 = 0 ;
  sword::ConfigEntMap *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SWFilterMgr_addRawFilters", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWFilterMgr, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWFilterMgr_addRawFilters" "', argument " "1"" of type '" "sword::SWFilterMgr *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWFilterMgr * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_sword__SWModule, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SWFilterMgr_addRawFilters" "', argument " "2"" of type '" "sword::SWModule *""'"); 
  }
  arg2 = reinterpret_cast< sword::SWModule * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_sword__multimapwithdefaultT_sword__SWBuf_sword__SWBuf_std__lessT_sword__SWBuf_t_t,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SWFilterMgr_addRawFilters" "', argument " "3"" of type '" "sword::ConfigEntMap &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SWFilterMgr_addRawFilters" "', argument " "3"" of type '" "sword::ConfigEntMap &""'"); 
  }
  arg3 = reinterpret_cast< sword::ConfigEntMap * >(argp3);
  {
    try {
      (arg1)->addRawFilters(arg2,*arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SWFilterMgr_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_sword__SWFilterMgr, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SWFilterMgr_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_StringMgr_setSystemStringMgr(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::StringMgr *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__StringMgr, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringMgr_setSystemStringMgr" "', argument " "1"" of type '" "sword::StringMgr *""'"); 
  }
  arg1 = reinterpret_cast< sword::StringMgr * >(argp1);
  {
    try {
      sword::StringMgr::setSystemStringMgr(arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringMgr_getSystemStringMgr(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::StringMgr *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "StringMgr_getSystemStringMgr", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (sword::StringMgr *)sword::StringMgr::getSystemStringMgr(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__StringMgr, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringMgr_hasUTF8Support(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "StringMgr_hasUTF8Support", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (bool)sword::StringMgr::hasUTF8Support(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringMgr_upperUTF8__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::StringMgr *arg1 = 0 ;
  char *arg2 = 0 ;
  unsigned int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  char *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__StringMgr, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringMgr_upperUTF8" "', argument " "1"" of type '" "sword::StringMgr const *""'"); 
  }
  arg1 = reinterpret_cast< sword::StringMgr * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StringMgr_upperUTF8" "', argument " "2"" of type '" "char *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "StringMgr_upperUTF8" "', argument " "3"" of type '" "unsigned int""'");
  } 
  arg3 = static_cast< unsigned int >(val3);
  {
    try {
      result = (char *)((sword::StringMgr const *)arg1)->upperUTF8(arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringMgr_upperUTF8__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::StringMgr *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  char *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__StringMgr, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringMgr_upperUTF8" "', argument " "1"" of type '" "sword::StringMgr const *""'"); 
  }
  arg1 = reinterpret_cast< sword::StringMgr * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StringMgr_upperUTF8" "', argument " "2"" of type '" "char *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    try {
      result = (char *)((sword::StringMgr const *)arg1)->upperUTF8(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringMgr_upperUTF8(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "StringMgr_upperUTF8", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__StringMgr, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_StringMgr_upperUTF8__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__StringMgr, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_StringMgr_upperUTF8__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'StringMgr_upperUTF8'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    sword::StringMgr::upperUTF8(char *,unsigned int) const\n"
    "    sword::StringMgr::upperUTF8(char *) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_StringMgr_lowerUTF8__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::StringMgr *arg1 = 0 ;
  char *arg2 = 0 ;
  unsigned int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  char *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__StringMgr, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringMgr_lowerUTF8" "', argument " "1"" of type '" "sword::StringMgr const *""'"); 
  }
  arg1 = reinterpret_cast< sword::StringMgr * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StringMgr_lowerUTF8" "', argument " "2"" of type '" "char *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "StringMgr_lowerUTF8" "', argument " "3"" of type '" "unsigned int""'");
  } 
  arg3 = static_cast< unsigned int >(val3);
  {
    try {
      result = (char *)((sword::StringMgr const *)arg1)->lowerUTF8(arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringMgr_lowerUTF8__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::StringMgr *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  char *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__StringMgr, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringMgr_lowerUTF8" "', argument " "1"" of type '" "sword::StringMgr const *""'"); 
  }
  arg1 = reinterpret_cast< sword::StringMgr * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StringMgr_lowerUTF8" "', argument " "2"" of type '" "char *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    try {
      result = (char *)((sword::StringMgr const *)arg1)->lowerUTF8(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringMgr_lowerUTF8(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "StringMgr_lowerUTF8", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__StringMgr, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_StringMgr_lowerUTF8__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__StringMgr, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_StringMgr_lowerUTF8__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'StringMgr_lowerUTF8'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    sword::StringMgr::lowerUTF8(char *,unsigned int) const\n"
    "    sword::StringMgr::lowerUTF8(char *) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_StringMgr_isUpper(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::StringMgr *arg1 = 0 ;
  SW_u32 arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "StringMgr_isUpper", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__StringMgr, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringMgr_isUpper" "', argument " "1"" of type '" "sword::StringMgr const *""'"); 
  }
  arg1 = reinterpret_cast< sword::StringMgr * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SW_u32,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StringMgr_isUpper" "', argument " "2"" of type '" "SW_u32""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "StringMgr_isUpper" "', argument " "2"" of type '" "SW_u32""'");
    } else {
      SW_u32 * temp = reinterpret_cast< SW_u32 * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    try {
      result = (bool)((sword::StringMgr const *)arg1)->isUpper(SWIG_STD_MOVE(arg2)); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringMgr_isLower(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::StringMgr *arg1 = 0 ;
  SW_u32 arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "StringMgr_isLower", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__StringMgr, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringMgr_isLower" "', argument " "1"" of type '" "sword::StringMgr const *""'"); 
  }
  arg1 = reinterpret_cast< sword::StringMgr * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SW_u32,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StringMgr_isLower" "', argument " "2"" of type '" "SW_u32""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "StringMgr_isLower" "', argument " "2"" of type '" "SW_u32""'");
    } else {
      SW_u32 * temp = reinterpret_cast< SW_u32 * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    try {
      result = (bool)((sword::StringMgr const *)arg1)->isLower(SWIG_STD_MOVE(arg2)); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringMgr_isDigit(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::StringMgr *arg1 = 0 ;
  SW_u32 arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "StringMgr_isDigit", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__StringMgr, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringMgr_isDigit" "', argument " "1"" of type '" "sword::StringMgr const *""'"); 
  }
  arg1 = reinterpret_cast< sword::StringMgr * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SW_u32,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StringMgr_isDigit" "', argument " "2"" of type '" "SW_u32""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "StringMgr_isDigit" "', argument " "2"" of type '" "SW_u32""'");
    } else {
      SW_u32 * temp = reinterpret_cast< SW_u32 * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    try {
      result = (bool)((sword::StringMgr const *)arg1)->isDigit(SWIG_STD_MOVE(arg2)); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringMgr_isAlpha(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::StringMgr *arg1 = 0 ;
  SW_u32 arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "StringMgr_isAlpha", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__StringMgr, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringMgr_isAlpha" "', argument " "1"" of type '" "sword::StringMgr const *""'"); 
  }
  arg1 = reinterpret_cast< sword::StringMgr * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SW_u32,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StringMgr_isAlpha" "', argument " "2"" of type '" "SW_u32""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "StringMgr_isAlpha" "', argument " "2"" of type '" "SW_u32""'");
    } else {
      SW_u32 * temp = reinterpret_cast< SW_u32 * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    try {
      result = (bool)((sword::StringMgr const *)arg1)->isAlpha(SWIG_STD_MOVE(arg2)); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringMgr_upperLatin1__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::StringMgr *arg1 = 0 ;
  char *arg2 = 0 ;
  unsigned int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  char *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__StringMgr, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringMgr_upperLatin1" "', argument " "1"" of type '" "sword::StringMgr const *""'"); 
  }
  arg1 = reinterpret_cast< sword::StringMgr * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StringMgr_upperLatin1" "', argument " "2"" of type '" "char *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "StringMgr_upperLatin1" "', argument " "3"" of type '" "unsigned int""'");
  } 
  arg3 = static_cast< unsigned int >(val3);
  {
    try {
      result = (char *)((sword::StringMgr const *)arg1)->upperLatin1(arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringMgr_upperLatin1__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::StringMgr *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  char *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__StringMgr, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringMgr_upperLatin1" "', argument " "1"" of type '" "sword::StringMgr const *""'"); 
  }
  arg1 = reinterpret_cast< sword::StringMgr * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StringMgr_upperLatin1" "', argument " "2"" of type '" "char *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    try {
      result = (char *)((sword::StringMgr const *)arg1)->upperLatin1(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringMgr_upperLatin1(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "StringMgr_upperLatin1", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__StringMgr, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_StringMgr_upperLatin1__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__StringMgr, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_StringMgr_upperLatin1__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'StringMgr_upperLatin1'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    sword::StringMgr::upperLatin1(char *,unsigned int) const\n"
    "    sword::StringMgr::upperLatin1(char *) const\n");
  return 0;
}


SWIGINTERN PyObject *StringMgr_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_sword__StringMgr, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_toupperstr__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  unsigned int arg2 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  char *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "toupperstr" "', argument " "1"" of type '" "char *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "toupperstr" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  {
    try {
      result = (char *)sword::toupperstr(arg1,arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_toupperstr__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  char *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "toupperstr" "', argument " "1"" of type '" "char *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  {
    try {
      result = (char *)sword::toupperstr(arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_toupperstr(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "toupperstr", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_toupperstr__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_toupperstr__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'toupperstr'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    sword::toupperstr(char *,unsigned int)\n"
    "    sword::toupperstr(char *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_tolowerstr__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  unsigned int arg2 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  char *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "tolowerstr" "', argument " "1"" of type '" "char *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "tolowerstr" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  {
    try {
      result = (char *)sword::tolowerstr(arg1,arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_tolowerstr__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  char *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "tolowerstr" "', argument " "1"" of type '" "char *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  {
    try {
      result = (char *)sword::tolowerstr(arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_tolowerstr(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "tolowerstr", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_tolowerstr__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_tolowerstr__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'tolowerstr'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    sword::tolowerstr(char *,unsigned int)\n"
    "    sword::tolowerstr(char *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_toupperstr_utf8__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  unsigned int arg2 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  char *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "toupperstr_utf8" "', argument " "1"" of type '" "char *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "toupperstr_utf8" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  {
    try {
      result = (char *)sword::toupperstr_utf8(arg1,arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_toupperstr_utf8__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  char *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "toupperstr_utf8" "', argument " "1"" of type '" "char *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  {
    try {
      result = (char *)sword::toupperstr_utf8(arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_toupperstr_utf8(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "toupperstr_utf8", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_toupperstr_utf8__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_toupperstr_utf8__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'toupperstr_utf8'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    sword::toupperstr_utf8(char *,unsigned int)\n"
    "    sword::toupperstr_utf8(char *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_PyStringMgr_upperUTF8__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  PyStringMgr *arg1 = 0 ;
  char *arg2 = 0 ;
  unsigned int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  char *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PyStringMgr, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyStringMgr_upperUTF8" "', argument " "1"" of type '" "PyStringMgr const *""'"); 
  }
  arg1 = reinterpret_cast< PyStringMgr * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyStringMgr_upperUTF8" "', argument " "2"" of type '" "char *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PyStringMgr_upperUTF8" "', argument " "3"" of type '" "unsigned int""'");
  } 
  arg3 = static_cast< unsigned int >(val3);
  {
    try {
      result = (char *)((PyStringMgr const *)arg1)->upperUTF8(arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_PyStringMgr_upperUTF8__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  PyStringMgr *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  char *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PyStringMgr, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyStringMgr_upperUTF8" "', argument " "1"" of type '" "PyStringMgr const *""'"); 
  }
  arg1 = reinterpret_cast< PyStringMgr * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyStringMgr_upperUTF8" "', argument " "2"" of type '" "char *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    try {
      result = (char *)((PyStringMgr const *)arg1)->upperUTF8(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_PyStringMgr_upperUTF8(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "PyStringMgr_upperUTF8", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_PyStringMgr, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_PyStringMgr_upperUTF8__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_PyStringMgr, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_PyStringMgr_upperUTF8__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PyStringMgr_upperUTF8'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    PyStringMgr::upperUTF8(char *,unsigned int) const\n"
    "    PyStringMgr::upperUTF8(char *) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_PyStringMgr_getUpper(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PyStringMgr *arg1 = 0 ;
  sword::SWBuf *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "PyStringMgr_getUpper", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PyStringMgr, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyStringMgr_getUpper" "', argument " "1"" of type '" "PyStringMgr const *""'"); 
  }
  arg1 = reinterpret_cast< PyStringMgr * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_sword__SWBuf, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyStringMgr_getUpper" "', argument " "2"" of type '" "sword::SWBuf *""'"); 
  }
  arg2 = reinterpret_cast< sword::SWBuf * >(argp2);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          Swig::DirectorPureVirtualException::raise("PyStringMgr::getUpper");
        } else {
          ((PyStringMgr const *)arg1)->getUpper(arg2);
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PyStringMgr(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PyObject *arg1 = 0 ;
  PyObject *swig_obj[1] ;
  PyStringMgr *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  arg1 = swig_obj[0];
  {
    try {
      if ( arg1 != Py_None ) {
        /* subclassed */
        result = (PyStringMgr *)new SwigDirector_PyStringMgr(arg1); 
      } else {
        SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing abstract class or protected constructor"); 
        SWIG_fail;
      }
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_PyStringMgr, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_PyStringMgr(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PyStringMgr *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PyStringMgr, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyStringMgr" "', argument " "1"" of type '" "PyStringMgr *""'"); 
  }
  arg1 = reinterpret_cast< PyStringMgr * >(argp1);
  {
    try {
      delete arg1; 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_disown_PyStringMgr(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PyStringMgr *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PyStringMgr, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "disown_PyStringMgr" "', argument " "1"" of type '" "PyStringMgr *""'"); 
  }
  arg1 = reinterpret_cast< PyStringMgr * >(argp1);
  {
    Swig::Director *director = SWIG_DIRECTOR_CAST(arg1);
    if (director) director->swig_disown();
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PyStringMgr_supportsUnicode(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PyStringMgr *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_PyStringMgr *darg = 0;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PyStringMgr, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyStringMgr_supportsUnicode" "', argument " "1"" of type '" "PyStringMgr const *""'"); 
  }
  arg1 = reinterpret_cast< PyStringMgr * >(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  if (!director || !(director->swig_get_inner("supportsUnicode"))) {
    SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing protected member supportsUnicode");
    SWIG_fail;
  }
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    darg = dynamic_cast<SwigDirector_PyStringMgr *>(arg1);
    {
      try {
        if (upcall) {
          result = (bool)((SwigDirector_PyStringMgr const *)darg)->supportsUnicodeSwigPublic();
        } else {
          result = (bool)((SwigDirector_PyStringMgr const *)darg)->supportsUnicode();
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *PyStringMgr_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_PyStringMgr, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *PyStringMgr_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_delete_SWSearchable(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWSearchable *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWSearchable, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SWSearchable" "', argument " "1"" of type '" "sword::SWSearchable *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWSearchable * >(argp1);
  {
    try {
      delete arg1; 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWSearchable_deleteSearchFramework(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWSearchable *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWSearchable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWSearchable_deleteSearchFramework" "', argument " "1"" of type '" "sword::SWSearchable *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWSearchable * >(argp1);
  {
    try {
      (arg1)->deleteSearchFramework(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWSearchable_hasSearchFramework(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWSearchable *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWSearchable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWSearchable_hasSearchFramework" "', argument " "1"" of type '" "sword::SWSearchable *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWSearchable * >(argp1);
  {
    try {
      result = (bool)(arg1)->hasSearchFramework(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWSearchable_isSearchOptimallySupported(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWSearchable *arg1 = 0 ;
  char *arg2 = 0 ;
  int arg3 ;
  int arg4 ;
  sword::SWKey *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  PyObject *swig_obj[5] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SWSearchable_isSearchOptimallySupported", 5, 5, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWSearchable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWSearchable_isSearchOptimallySupported" "', argument " "1"" of type '" "sword::SWSearchable *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWSearchable * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SWSearchable_isSearchOptimallySupported" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SWSearchable_isSearchOptimallySupported" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SWSearchable_isSearchOptimallySupported" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5,SWIGTYPE_p_sword__SWKey, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "SWSearchable_isSearchOptimallySupported" "', argument " "5"" of type '" "sword::SWKey *""'"); 
  }
  arg5 = reinterpret_cast< sword::SWKey * >(argp5);
  {
    try {
      result = (bool)(arg1)->isSearchOptimallySupported((char const *)arg2,arg3,arg4,arg5); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWSearchable_isSearchSupported__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::SWSearchable *arg1 = 0 ;
  char *arg2 = 0 ;
  int arg3 ;
  int arg4 ;
  sword::SWKey *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  bool result;
  
  (void)self;
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWSearchable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWSearchable_isSearchSupported" "', argument " "1"" of type '" "sword::SWSearchable *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWSearchable * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SWSearchable_isSearchSupported" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SWSearchable_isSearchSupported" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SWSearchable_isSearchSupported" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5,SWIGTYPE_p_sword__SWKey, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "SWSearchable_isSearchSupported" "', argument " "5"" of type '" "sword::SWKey *""'"); 
  }
  arg5 = reinterpret_cast< sword::SWKey * >(argp5);
  {
    try {
      result = (bool)sword_SWSearchable_isSearchSupported__SWIG_0(arg1,(char const *)arg2,arg3,arg4,arg5); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWSearchable_isSearchSupported__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::SWSearchable *arg1 = 0 ;
  char *arg2 = 0 ;
  int arg3 ;
  int arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  bool result;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWSearchable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWSearchable_isSearchSupported" "', argument " "1"" of type '" "sword::SWSearchable *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWSearchable * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SWSearchable_isSearchSupported" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SWSearchable_isSearchSupported" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SWSearchable_isSearchSupported" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  {
    try {
      result = (bool)sword_SWSearchable_isSearchSupported__SWIG_0(arg1,(char const *)arg2,arg3,arg4); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWSearchable_isSearchSupported__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::SWSearchable *arg1 = 0 ;
  char *arg2 = 0 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  bool result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWSearchable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWSearchable_isSearchSupported" "', argument " "1"" of type '" "sword::SWSearchable *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWSearchable * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SWSearchable_isSearchSupported" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SWSearchable_isSearchSupported" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  {
    try {
      result = (bool)sword_SWSearchable_isSearchSupported__SWIG_0(arg1,(char const *)arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWSearchable_isSearchSupported__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::SWSearchable *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  bool result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWSearchable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWSearchable_isSearchSupported" "', argument " "1"" of type '" "sword::SWSearchable *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWSearchable * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SWSearchable_isSearchSupported" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    try {
      result = (bool)sword_SWSearchable_isSearchSupported__SWIG_0(arg1,(char const *)arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWSearchable_isSearchSupported(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SWSearchable_isSearchSupported", 0, 5, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__SWSearchable, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SWSearchable_isSearchSupported__SWIG_3(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__SWSearchable, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SWSearchable_isSearchSupported__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__SWSearchable, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_SWSearchable_isSearchSupported__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__SWSearchable, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_sword__SWKey, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_SWSearchable_isSearchSupported__SWIG_0(self, argc, argv);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SWSearchable_isSearchSupported'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    sword::SWSearchable::isSearchSupported(char const *,int,int,sword::SWKey *)\n"
    "    sword::SWSearchable::isSearchSupported(char const *,int,int)\n"
    "    sword::SWSearchable::isSearchSupported(char const *,int)\n"
    "    sword::SWSearchable::isSearchSupported(char const *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SWSearchable_doSearch__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::SWSearchable *arg1 = 0 ;
  char *arg2 = 0 ;
  int arg3 ;
  int arg4 ;
  sword::SWKey *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  sword::ListKey *result = 0 ;
  
  (void)self;
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWSearchable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWSearchable_doSearch" "', argument " "1"" of type '" "sword::SWSearchable *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWSearchable * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SWSearchable_doSearch" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SWSearchable_doSearch" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SWSearchable_doSearch" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5,SWIGTYPE_p_sword__SWKey, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "SWSearchable_doSearch" "', argument " "5"" of type '" "sword::SWKey *""'"); 
  }
  arg5 = reinterpret_cast< sword::SWKey * >(argp5);
  {
    try {
      result = (sword::ListKey *) &sword_SWSearchable_doSearch__SWIG_0(arg1,(char const *)arg2,arg3,arg4,arg5); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__ListKey, 0 |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWSearchable_doSearch__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::SWSearchable *arg1 = 0 ;
  char *arg2 = 0 ;
  int arg3 ;
  int arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  sword::ListKey *result = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWSearchable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWSearchable_doSearch" "', argument " "1"" of type '" "sword::SWSearchable *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWSearchable * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SWSearchable_doSearch" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SWSearchable_doSearch" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SWSearchable_doSearch" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  {
    try {
      result = (sword::ListKey *) &sword_SWSearchable_doSearch__SWIG_0(arg1,(char const *)arg2,arg3,arg4); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__ListKey, 0 |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWSearchable_doSearch__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::SWSearchable *arg1 = 0 ;
  char *arg2 = 0 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  sword::ListKey *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWSearchable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWSearchable_doSearch" "', argument " "1"" of type '" "sword::SWSearchable *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWSearchable * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SWSearchable_doSearch" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SWSearchable_doSearch" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  {
    try {
      result = (sword::ListKey *) &sword_SWSearchable_doSearch__SWIG_0(arg1,(char const *)arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__ListKey, 0 |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWSearchable_doSearch__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::SWSearchable *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  sword::ListKey *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWSearchable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWSearchable_doSearch" "', argument " "1"" of type '" "sword::SWSearchable *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWSearchable * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SWSearchable_doSearch" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    try {
      result = (sword::ListKey *) &sword_SWSearchable_doSearch__SWIG_0(arg1,(char const *)arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__ListKey, 0 |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWSearchable_doSearch(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SWSearchable_doSearch", 0, 5, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__SWSearchable, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SWSearchable_doSearch__SWIG_3(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__SWSearchable, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SWSearchable_doSearch__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__SWSearchable, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_SWSearchable_doSearch__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__SWSearchable, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_sword__SWKey, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_SWSearchable_doSearch__SWIG_0(self, argc, argv);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SWSearchable_doSearch'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    sword::SWSearchable::doSearch(char const *,int,int,sword::SWKey *)\n"
    "    sword::SWSearchable::doSearch(char const *,int,int)\n"
    "    sword::SWSearchable::doSearch(char const *,int)\n"
    "    sword::SWSearchable::doSearch(char const *)\n");
  return 0;
}


SWIGINTERN PyObject *SWSearchable_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_sword__SWSearchable, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_SWModule_terminateSearch_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWModule *arg1 = 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SWModule_terminateSearch_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWModule_terminateSearch_set" "', argument " "1"" of type '" "sword::SWModule *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWModule * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SWModule_terminateSearch_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->terminateSearch = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWModule_terminateSearch_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWModule *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWModule_terminateSearch_get" "', argument " "1"" of type '" "sword::SWModule *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWModule * >(argp1);
  result = (bool) ((arg1)->terminateSearch);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SWModule(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWModule *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWModule, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SWModule" "', argument " "1"" of type '" "sword::SWModule *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWModule * >(argp1);
  {
    try {
      delete arg1; 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWModule_popError(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWModule *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWModule_popError" "', argument " "1"" of type '" "sword::SWModule *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWModule * >(argp1);
  {
    try {
      result = (char)(arg1)->popError(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_char(static_cast< char >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWModule_isUnicode(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWModule *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWModule_isUnicode" "', argument " "1"" of type '" "sword::SWModule const *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWModule * >(argp1);
  {
    try {
      result = (bool)((sword::SWModule const *)arg1)->isUnicode(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWModule_getConfigEntry(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWModule *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  char *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SWModule_getConfigEntry", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWModule_getConfigEntry" "', argument " "1"" of type '" "sword::SWModule const *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWModule * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SWModule_getConfigEntry" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    try {
      result = (char *)((sword::SWModule const *)arg1)->getConfigEntry((char const *)arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWModule_getBibliography__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::SWModule *arg1 = 0 ;
  unsigned char arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  sword::SWBuf result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWModule_getBibliography" "', argument " "1"" of type '" "sword::SWModule const *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWModule * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SWModule_getBibliography" "', argument " "2"" of type '" "unsigned char""'");
  } 
  arg2 = static_cast< unsigned char >(val2);
  {
    try {
      result = ((sword::SWModule const *)arg1)->getBibliography(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj((new sword::SWBuf(result)), SWIGTYPE_p_sword__SWBuf, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWModule_getBibliography__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::SWModule *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  sword::SWBuf result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWModule_getBibliography" "', argument " "1"" of type '" "sword::SWModule const *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWModule * >(argp1);
  {
    try {
      result = ((sword::SWModule const *)arg1)->getBibliography(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj((new sword::SWBuf(result)), SWIGTYPE_p_sword__SWBuf, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWModule_getBibliography(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SWModule_getBibliography", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__SWModule, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SWModule_getBibliography__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__SWModule, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_char(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SWModule_getBibliography__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SWModule_getBibliography'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    sword::SWModule::getBibliography(unsigned char) const\n"
    "    sword::SWModule::getBibliography() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SWModule_getEntrySize(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWModule *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWModule_getEntrySize" "', argument " "1"" of type '" "sword::SWModule const *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWModule * >(argp1);
  {
    try {
      result = (int)((sword::SWModule const *)arg1)->getEntrySize(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWModule_setKey(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWModule *arg1 = 0 ;
  sword::SWKey *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  char result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SWModule_setKey", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWModule_setKey" "', argument " "1"" of type '" "sword::SWModule *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWModule * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_sword__SWKey, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SWModule_setKey" "', argument " "2"" of type '" "sword::SWKey const *""'"); 
  }
  arg2 = reinterpret_cast< sword::SWKey * >(argp2);
  {
    try {
      result = (char)(arg1)->setKey((sword::SWKey const *)arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_char(static_cast< char >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWModule_setKeyText(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWModule *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  char result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SWModule_setKeyText", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWModule_setKeyText" "', argument " "1"" of type '" "sword::SWModule *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWModule * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SWModule_setKeyText" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    try {
      result = (char)(arg1)->setKeyText((char const *)arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_char(static_cast< char >(result));
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWModule_getKey(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWModule *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  sword::SWKey *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWModule_getKey" "', argument " "1"" of type '" "sword::SWModule const *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWModule * >(argp1);
  {
    try {
      result = (sword::SWKey *)((sword::SWModule const *)arg1)->getKey(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__SWKey, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWModule_getKeyText(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWModule *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWModule_getKeyText" "', argument " "1"" of type '" "sword::SWModule const *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWModule * >(argp1);
  {
    try {
      result = (char *)((sword::SWModule const *)arg1)->getKeyText(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWModule_getIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWModule *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  long result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWModule_getIndex" "', argument " "1"" of type '" "sword::SWModule const *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWModule * >(argp1);
  {
    try {
      result = (long)((sword::SWModule const *)arg1)->getIndex(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_long(static_cast< long >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWModule_setIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWModule *arg1 = 0 ;
  long arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  long val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SWModule_setIndex", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWModule_setIndex" "', argument " "1"" of type '" "sword::SWModule *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWModule * >(argp1);
  ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SWModule_setIndex" "', argument " "2"" of type '" "long""'");
  } 
  arg2 = static_cast< long >(val2);
  {
    try {
      (arg1)->setIndex(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWModule_display(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWModule *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWModule_display" "', argument " "1"" of type '" "sword::SWModule *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWModule * >(argp1);
  {
    try {
      result = (char)(arg1)->display(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_char(static_cast< char >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWModule_getDisplay(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWModule *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  sword::SWDisplay *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWModule_getDisplay" "', argument " "1"" of type '" "sword::SWModule const *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWModule * >(argp1);
  {
    try {
      result = (sword::SWDisplay *)((sword::SWModule const *)arg1)->getDisplay(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__SWDisplay, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWModule_setDisplay(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWModule *arg1 = 0 ;
  sword::SWDisplay *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SWModule_setDisplay", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWModule_setDisplay" "', argument " "1"" of type '" "sword::SWModule *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWModule * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_sword__SWDisplay, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SWModule_setDisplay" "', argument " "2"" of type '" "sword::SWDisplay *""'"); 
  }
  arg2 = reinterpret_cast< sword::SWDisplay * >(argp2);
  {
    try {
      (arg1)->setDisplay(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWModule_getName(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWModule *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWModule_getName" "', argument " "1"" of type '" "sword::SWModule const *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWModule * >(argp1);
  {
    try {
      result = (char *)((sword::SWModule const *)arg1)->getName(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWModule_getDescription(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWModule *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWModule_getDescription" "', argument " "1"" of type '" "sword::SWModule const *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWModule * >(argp1);
  {
    try {
      result = (char *)((sword::SWModule const *)arg1)->getDescription(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWModule_getType(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWModule *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWModule_getType" "', argument " "1"" of type '" "sword::SWModule const *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWModule * >(argp1);
  {
    try {
      result = (char *)((sword::SWModule const *)arg1)->getType(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWModule_setType(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWModule *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SWModule_setType", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWModule_setType" "', argument " "1"" of type '" "sword::SWModule *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWModule * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SWModule_setType" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    try {
      (arg1)->setType((char const *)arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWModule_getDirection(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWModule *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWModule_getDirection" "', argument " "1"" of type '" "sword::SWModule const *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWModule * >(argp1);
  {
    try {
      result = (char)((sword::SWModule const *)arg1)->getDirection(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_char(static_cast< char >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWModule_getEncoding(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWModule *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWModule_getEncoding" "', argument " "1"" of type '" "sword::SWModule const *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWModule * >(argp1);
  {
    try {
      result = (char)((sword::SWModule const *)arg1)->getEncoding(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_char(static_cast< char >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWModule_getMarkup(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWModule *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWModule_getMarkup" "', argument " "1"" of type '" "sword::SWModule const *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWModule * >(argp1);
  {
    try {
      result = (char)((sword::SWModule const *)arg1)->getMarkup(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_char(static_cast< char >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWModule_getLanguage(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWModule *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWModule_getLanguage" "', argument " "1"" of type '" "sword::SWModule const *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWModule * >(argp1);
  {
    try {
      result = (char *)((sword::SWModule const *)arg1)->getLanguage(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWModule_createKey(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWModule *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  sword::SWKey *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWModule_createKey" "', argument " "1"" of type '" "sword::SWModule const *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWModule * >(argp1);
  {
    try {
      result = (sword::SWKey *)((sword::SWModule const *)arg1)->createKey(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__SWKey, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWModule_getRawEntryBuf(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWModule *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  sword::SWBuf *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWModule_getRawEntryBuf" "', argument " "1"" of type '" "sword::SWModule const *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWModule * >(argp1);
  {
    try {
      result = (sword::SWBuf *) &((sword::SWModule const *)arg1)->getRawEntryBuf(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__SWBuf, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWModule_getRawEntry(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWModule *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWModule_getRawEntry" "', argument " "1"" of type '" "sword::SWModule const *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWModule * >(argp1);
  {
    try {
      result = (char *)((sword::SWModule const *)arg1)->getRawEntry(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWModule_isWritable(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWModule *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWModule_isWritable" "', argument " "1"" of type '" "sword::SWModule const *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWModule * >(argp1);
  {
    try {
      result = (bool)((sword::SWModule const *)arg1)->isWritable(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWModule_createModule(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  PyObject *swig_obj[1] ;
  signed char result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWModule_createModule" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  {
    try {
      result = (signed char)sword::SWModule::createModule((char const *)arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_signed_SS_char(static_cast< signed char >(result));
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWModule_setEntry__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::SWModule *arg1 = 0 ;
  char *arg2 = 0 ;
  long arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  long val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWModule_setEntry" "', argument " "1"" of type '" "sword::SWModule *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWModule * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SWModule_setEntry" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  ecode3 = SWIG_AsVal_long(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SWModule_setEntry" "', argument " "3"" of type '" "long""'");
  } 
  arg3 = static_cast< long >(val3);
  {
    try {
      (arg1)->setEntry((char const *)arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWModule_setEntry__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::SWModule *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWModule_setEntry" "', argument " "1"" of type '" "sword::SWModule *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWModule * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SWModule_setEntry" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    try {
      (arg1)->setEntry((char const *)arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWModule_setEntry(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SWModule_setEntry", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__SWModule, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SWModule_setEntry__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__SWModule, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_long(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SWModule_setEntry__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SWModule_setEntry'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    sword::SWModule::setEntry(char const *,long)\n"
    "    sword::SWModule::setEntry(char const *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SWModule_linkEntry(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWModule *arg1 = 0 ;
  sword::SWKey *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SWModule_linkEntry", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWModule_linkEntry" "', argument " "1"" of type '" "sword::SWModule *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWModule * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_sword__SWKey, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SWModule_linkEntry" "', argument " "2"" of type '" "sword::SWKey const *""'"); 
  }
  arg2 = reinterpret_cast< sword::SWKey * >(argp2);
  {
    try {
      (arg1)->linkEntry((sword::SWKey const *)arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWModule_deleteEntry(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWModule *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWModule_deleteEntry" "', argument " "1"" of type '" "sword::SWModule *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWModule * >(argp1);
  {
    try {
      (arg1)->deleteEntry(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWModule_decrement__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::SWModule *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWModule_decrement" "', argument " "1"" of type '" "sword::SWModule *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWModule * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SWModule_decrement" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    try {
      (arg1)->decrement(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWModule_decrement__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::SWModule *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWModule_decrement" "', argument " "1"" of type '" "sword::SWModule *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWModule * >(argp1);
  {
    try {
      (arg1)->decrement(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWModule_decrement(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SWModule_decrement", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__SWModule, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SWModule_decrement__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__SWModule, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SWModule_decrement__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SWModule_decrement'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    sword::SWModule::decrement(int)\n"
    "    sword::SWModule::decrement()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SWModule_increment__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::SWModule *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWModule_increment" "', argument " "1"" of type '" "sword::SWModule *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWModule * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SWModule_increment" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    try {
      (arg1)->increment(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWModule_increment__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::SWModule *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWModule_increment" "', argument " "1"" of type '" "sword::SWModule *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWModule * >(argp1);
  {
    try {
      (arg1)->increment(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWModule_increment(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SWModule_increment", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__SWModule, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SWModule_increment__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__SWModule, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SWModule_increment__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SWModule_increment'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    sword::SWModule::increment(int)\n"
    "    sword::SWModule::increment()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SWModule_setPosition(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWModule *arg1 = 0 ;
  SwigValueWrapper< sword::SW_POSITION > arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SWModule_setPosition", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWModule_setPosition" "', argument " "1"" of type '" "sword::SWModule *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWModule * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_sword__SW_POSITION,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SWModule_setPosition" "', argument " "2"" of type '" "sword::SW_POSITION""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SWModule_setPosition" "', argument " "2"" of type '" "sword::SW_POSITION""'");
    } else {
      sword::SW_POSITION * temp = reinterpret_cast< sword::SW_POSITION * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    try {
      (arg1)->setPosition(SWIG_STD_MOVE(arg2)); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWModule_addRenderFilter(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWModule *arg1 = 0 ;
  sword::SWFilter *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  sword::SWModule *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SWModule_addRenderFilter", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWModule_addRenderFilter" "', argument " "1"" of type '" "sword::SWModule *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWModule * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_sword__SWFilter, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SWModule_addRenderFilter" "', argument " "2"" of type '" "sword::SWFilter *""'"); 
  }
  arg2 = reinterpret_cast< sword::SWFilter * >(argp2);
  {
    try {
      result = (sword::SWModule *) &(arg1)->addRenderFilter(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__SWModule, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWModule_getRenderFilters(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWModule *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  sword::FilterList *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWModule_getRenderFilters" "', argument " "1"" of type '" "sword::SWModule const *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWModule * >(argp1);
  {
    try {
      result = (sword::FilterList *) &((sword::SWModule const *)arg1)->getRenderFilters(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__listT_sword__SWFilter_p_std__allocatorT_sword__SWFilter_p_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWModule_removeRenderFilter(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWModule *arg1 = 0 ;
  sword::SWFilter *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  sword::SWModule *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SWModule_removeRenderFilter", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWModule_removeRenderFilter" "', argument " "1"" of type '" "sword::SWModule *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWModule * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_sword__SWFilter, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SWModule_removeRenderFilter" "', argument " "2"" of type '" "sword::SWFilter *""'"); 
  }
  arg2 = reinterpret_cast< sword::SWFilter * >(argp2);
  {
    try {
      result = (sword::SWModule *) &(arg1)->removeRenderFilter(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__SWModule, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWModule_replaceRenderFilter(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWModule *arg1 = 0 ;
  sword::SWFilter *arg2 = 0 ;
  sword::SWFilter *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  sword::SWModule *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SWModule_replaceRenderFilter", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWModule_replaceRenderFilter" "', argument " "1"" of type '" "sword::SWModule *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWModule * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_sword__SWFilter, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SWModule_replaceRenderFilter" "', argument " "2"" of type '" "sword::SWFilter *""'"); 
  }
  arg2 = reinterpret_cast< sword::SWFilter * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_sword__SWFilter, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SWModule_replaceRenderFilter" "', argument " "3"" of type '" "sword::SWFilter *""'"); 
  }
  arg3 = reinterpret_cast< sword::SWFilter * >(argp3);
  {
    try {
      result = (sword::SWModule *) &(arg1)->replaceRenderFilter(arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__SWModule, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWModule_renderFilter(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWModule *arg1 = 0 ;
  sword::SWBuf *arg2 = 0 ;
  sword::SWKey *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SWModule_renderFilter", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWModule_renderFilter" "', argument " "1"" of type '" "sword::SWModule const *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWModule * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_sword__SWBuf,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SWModule_renderFilter" "', argument " "2"" of type '" "sword::SWBuf &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SWModule_renderFilter" "', argument " "2"" of type '" "sword::SWBuf &""'"); 
  }
  arg2 = reinterpret_cast< sword::SWBuf * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_sword__SWKey, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SWModule_renderFilter" "', argument " "3"" of type '" "sword::SWKey const *""'"); 
  }
  arg3 = reinterpret_cast< sword::SWKey * >(argp3);
  {
    try {
      ((sword::SWModule const *)arg1)->renderFilter(*arg2,(sword::SWKey const *)arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWModule_addEncodingFilter(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWModule *arg1 = 0 ;
  sword::SWFilter *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  sword::SWModule *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SWModule_addEncodingFilter", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWModule_addEncodingFilter" "', argument " "1"" of type '" "sword::SWModule *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWModule * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_sword__SWFilter, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SWModule_addEncodingFilter" "', argument " "2"" of type '" "sword::SWFilter *""'"); 
  }
  arg2 = reinterpret_cast< sword::SWFilter * >(argp2);
  {
    try {
      result = (sword::SWModule *) &(arg1)->addEncodingFilter(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__SWModule, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWModule_removeEncodingFilter(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWModule *arg1 = 0 ;
  sword::SWFilter *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  sword::SWModule *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SWModule_removeEncodingFilter", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWModule_removeEncodingFilter" "', argument " "1"" of type '" "sword::SWModule *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWModule * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_sword__SWFilter, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SWModule_removeEncodingFilter" "', argument " "2"" of type '" "sword::SWFilter *""'"); 
  }
  arg2 = reinterpret_cast< sword::SWFilter * >(argp2);
  {
    try {
      result = (sword::SWModule *) &(arg1)->removeEncodingFilter(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__SWModule, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWModule_replaceEncodingFilter(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWModule *arg1 = 0 ;
  sword::SWFilter *arg2 = 0 ;
  sword::SWFilter *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  sword::SWModule *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SWModule_replaceEncodingFilter", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWModule_replaceEncodingFilter" "', argument " "1"" of type '" "sword::SWModule *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWModule * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_sword__SWFilter, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SWModule_replaceEncodingFilter" "', argument " "2"" of type '" "sword::SWFilter *""'"); 
  }
  arg2 = reinterpret_cast< sword::SWFilter * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_sword__SWFilter, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SWModule_replaceEncodingFilter" "', argument " "3"" of type '" "sword::SWFilter *""'"); 
  }
  arg3 = reinterpret_cast< sword::SWFilter * >(argp3);
  {
    try {
      result = (sword::SWModule *) &(arg1)->replaceEncodingFilter(arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__SWModule, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWModule_encodingFilter(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWModule *arg1 = 0 ;
  sword::SWBuf *arg2 = 0 ;
  sword::SWKey *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SWModule_encodingFilter", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWModule_encodingFilter" "', argument " "1"" of type '" "sword::SWModule const *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWModule * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_sword__SWBuf,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SWModule_encodingFilter" "', argument " "2"" of type '" "sword::SWBuf &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SWModule_encodingFilter" "', argument " "2"" of type '" "sword::SWBuf &""'"); 
  }
  arg2 = reinterpret_cast< sword::SWBuf * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_sword__SWKey, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SWModule_encodingFilter" "', argument " "3"" of type '" "sword::SWKey const *""'"); 
  }
  arg3 = reinterpret_cast< sword::SWKey * >(argp3);
  {
    try {
      ((sword::SWModule const *)arg1)->encodingFilter(*arg2,(sword::SWKey const *)arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWModule_addStripFilter(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWModule *arg1 = 0 ;
  sword::SWFilter *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  sword::SWModule *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SWModule_addStripFilter", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWModule_addStripFilter" "', argument " "1"" of type '" "sword::SWModule *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWModule * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_sword__SWFilter, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SWModule_addStripFilter" "', argument " "2"" of type '" "sword::SWFilter *""'"); 
  }
  arg2 = reinterpret_cast< sword::SWFilter * >(argp2);
  {
    try {
      result = (sword::SWModule *) &(arg1)->addStripFilter(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__SWModule, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWModule_addRawFilter(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWModule *arg1 = 0 ;
  sword::SWFilter *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  sword::SWModule *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SWModule_addRawFilter", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWModule_addRawFilter" "', argument " "1"" of type '" "sword::SWModule *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWModule * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_sword__SWFilter, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SWModule_addRawFilter" "', argument " "2"" of type '" "sword::SWFilter *""'"); 
  }
  arg2 = reinterpret_cast< sword::SWFilter * >(argp2);
  {
    try {
      result = (sword::SWModule *) &(arg1)->addRawFilter(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__SWModule, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWModule_stripFilter(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWModule *arg1 = 0 ;
  sword::SWBuf *arg2 = 0 ;
  sword::SWKey *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SWModule_stripFilter", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWModule_stripFilter" "', argument " "1"" of type '" "sword::SWModule const *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWModule * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_sword__SWBuf,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SWModule_stripFilter" "', argument " "2"" of type '" "sword::SWBuf &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SWModule_stripFilter" "', argument " "2"" of type '" "sword::SWBuf &""'"); 
  }
  arg2 = reinterpret_cast< sword::SWBuf * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_sword__SWKey, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SWModule_stripFilter" "', argument " "3"" of type '" "sword::SWKey const *""'"); 
  }
  arg3 = reinterpret_cast< sword::SWKey * >(argp3);
  {
    try {
      ((sword::SWModule const *)arg1)->stripFilter(*arg2,(sword::SWKey const *)arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWModule_rawFilter(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWModule *arg1 = 0 ;
  sword::SWBuf *arg2 = 0 ;
  sword::SWKey *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SWModule_rawFilter", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWModule_rawFilter" "', argument " "1"" of type '" "sword::SWModule const *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWModule * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_sword__SWBuf,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SWModule_rawFilter" "', argument " "2"" of type '" "sword::SWBuf &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SWModule_rawFilter" "', argument " "2"" of type '" "sword::SWBuf &""'"); 
  }
  arg2 = reinterpret_cast< sword::SWBuf * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_sword__SWKey, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SWModule_rawFilter" "', argument " "3"" of type '" "sword::SWKey const *""'"); 
  }
  arg3 = reinterpret_cast< sword::SWKey * >(argp3);
  {
    try {
      ((sword::SWModule const *)arg1)->rawFilter(*arg2,(sword::SWKey const *)arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWModule_addOptionFilter(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWModule *arg1 = 0 ;
  sword::SWOptionFilter *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  sword::SWModule *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SWModule_addOptionFilter", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWModule_addOptionFilter" "', argument " "1"" of type '" "sword::SWModule *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWModule * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_sword__SWOptionFilter, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SWModule_addOptionFilter" "', argument " "2"" of type '" "sword::SWOptionFilter *""'"); 
  }
  arg2 = reinterpret_cast< sword::SWOptionFilter * >(argp2);
  {
    try {
      result = (sword::SWModule *) &(arg1)->addOptionFilter(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__SWModule, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWModule_getOptionFilters(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWModule *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  sword::OptionFilterList *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWModule_getOptionFilters" "', argument " "1"" of type '" "sword::SWModule const *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWModule * >(argp1);
  {
    try {
      result = (sword::OptionFilterList *) &((sword::SWModule const *)arg1)->getOptionFilters(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__listT_sword__SWOptionFilter_p_std__allocatorT_sword__SWOptionFilter_p_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWModule_optionFilter(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWModule *arg1 = 0 ;
  sword::SWBuf *arg2 = 0 ;
  sword::SWKey *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SWModule_optionFilter", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWModule_optionFilter" "', argument " "1"" of type '" "sword::SWModule const *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWModule * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_sword__SWBuf,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SWModule_optionFilter" "', argument " "2"" of type '" "sword::SWBuf &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SWModule_optionFilter" "', argument " "2"" of type '" "sword::SWBuf &""'"); 
  }
  arg2 = reinterpret_cast< sword::SWBuf * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_sword__SWKey, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SWModule_optionFilter" "', argument " "3"" of type '" "sword::SWKey const *""'"); 
  }
  arg3 = reinterpret_cast< sword::SWKey * >(argp3);
  {
    try {
      ((sword::SWModule const *)arg1)->optionFilter(*arg2,(sword::SWKey const *)arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWModule_stripText__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::SWModule *arg1 = 0 ;
  char *arg2 = 0 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  char *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWModule_stripText" "', argument " "1"" of type '" "sword::SWModule *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWModule * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SWModule_stripText" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SWModule_stripText" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  {
    try {
      result = (char *)(arg1)->stripText((char const *)arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWModule_stripText__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::SWModule *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  char *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWModule_stripText" "', argument " "1"" of type '" "sword::SWModule *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWModule * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SWModule_stripText" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    try {
      result = (char *)(arg1)->stripText((char const *)arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWModule_stripText__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::SWModule *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWModule_stripText" "', argument " "1"" of type '" "sword::SWModule *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWModule * >(argp1);
  {
    try {
      result = (char *)(arg1)->stripText(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWModule_renderText__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::SWModule *arg1 = 0 ;
  char *arg2 = 0 ;
  int arg3 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  sword::SWBuf result;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWModule_renderText" "', argument " "1"" of type '" "sword::SWModule const *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWModule * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SWModule_renderText" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SWModule_renderText" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SWModule_renderText" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  {
    try {
      result = ((sword::SWModule const *)arg1)->renderText((char const *)arg2,arg3,arg4); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj((new sword::SWBuf(result)), SWIGTYPE_p_sword__SWBuf, SWIG_POINTER_OWN |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWModule_renderText__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::SWModule *arg1 = 0 ;
  char *arg2 = 0 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  sword::SWBuf result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWModule_renderText" "', argument " "1"" of type '" "sword::SWModule const *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWModule * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SWModule_renderText" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SWModule_renderText" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  {
    try {
      result = ((sword::SWModule const *)arg1)->renderText((char const *)arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj((new sword::SWBuf(result)), SWIGTYPE_p_sword__SWBuf, SWIG_POINTER_OWN |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWModule_renderText__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::SWModule *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  sword::SWBuf result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWModule_renderText" "', argument " "1"" of type '" "sword::SWModule const *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWModule * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SWModule_renderText" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    try {
      result = ((sword::SWModule const *)arg1)->renderText((char const *)arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj((new sword::SWBuf(result)), SWIGTYPE_p_sword__SWBuf, SWIG_POINTER_OWN |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWModule_renderText__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::SWModule *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  sword::SWBuf result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWModule_renderText" "', argument " "1"" of type '" "sword::SWModule *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWModule * >(argp1);
  {
    try {
      result = (arg1)->renderText(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj((new sword::SWBuf(result)), SWIGTYPE_p_sword__SWBuf, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWModule_getRenderHeader(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWModule *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWModule_getRenderHeader" "', argument " "1"" of type '" "sword::SWModule const *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWModule * >(argp1);
  {
    try {
      result = (char *)((sword::SWModule const *)arg1)->getRenderHeader(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWModule_stripText__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::SWModule *arg1 = 0 ;
  sword::SWKey *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  char *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWModule_stripText" "', argument " "1"" of type '" "sword::SWModule *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWModule * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_sword__SWKey, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SWModule_stripText" "', argument " "2"" of type '" "sword::SWKey const *""'"); 
  }
  arg2 = reinterpret_cast< sword::SWKey * >(argp2);
  {
    try {
      result = (char *)(arg1)->stripText((sword::SWKey const *)arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWModule_stripText(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SWModule_stripText", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__SWModule, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SWModule_stripText__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__SWModule, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_sword__SWKey, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SWModule_stripText__SWIG_3(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__SWModule, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SWModule_stripText__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__SWModule, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SWModule_stripText__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SWModule_stripText'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    sword::SWModule::stripText(char const *,int)\n"
    "    sword::SWModule::stripText(char const *)\n"
    "    sword::SWModule::stripText()\n"
    "    sword::SWModule::stripText(sword::SWKey const *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SWModule_renderText__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::SWModule *arg1 = 0 ;
  sword::SWKey *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  sword::SWBuf result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWModule_renderText" "', argument " "1"" of type '" "sword::SWModule *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWModule * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_sword__SWKey, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SWModule_renderText" "', argument " "2"" of type '" "sword::SWKey const *""'"); 
  }
  arg2 = reinterpret_cast< sword::SWKey * >(argp2);
  {
    try {
      result = (arg1)->renderText((sword::SWKey const *)arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj((new sword::SWBuf(result)), SWIGTYPE_p_sword__SWBuf, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWModule_renderText(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SWModule_renderText", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__SWModule, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SWModule_renderText__SWIG_3(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__SWModule, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_sword__SWKey, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SWModule_renderText__SWIG_4(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__SWModule, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SWModule_renderText__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__SWModule, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SWModule_renderText__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__SWModule, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_SWModule_renderText__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SWModule_renderText'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    sword::SWModule::renderText(char const *,int,bool) const\n"
    "    sword::SWModule::renderText(char const *,int) const\n"
    "    sword::SWModule::renderText(char const *) const\n"
    "    sword::SWModule::renderText()\n"
    "    sword::SWModule::renderText(sword::SWKey const *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SWModule_setSkipConsecutiveLinks(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWModule *arg1 = 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SWModule_setSkipConsecutiveLinks", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWModule_setSkipConsecutiveLinks" "', argument " "1"" of type '" "sword::SWModule *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWModule * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SWModule_setSkipConsecutiveLinks" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    try {
      (arg1)->setSkipConsecutiveLinks(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWModule_isSkipConsecutiveLinks(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWModule *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWModule_isSkipConsecutiveLinks" "', argument " "1"" of type '" "sword::SWModule *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWModule * >(argp1);
  {
    try {
      result = (bool)(arg1)->isSkipConsecutiveLinks(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWModule_isLinked(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWModule *arg1 = 0 ;
  sword::SWKey *arg2 = 0 ;
  sword::SWKey *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SWModule_isLinked", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWModule_isLinked" "', argument " "1"" of type '" "sword::SWModule const *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWModule * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_sword__SWKey, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SWModule_isLinked" "', argument " "2"" of type '" "sword::SWKey const *""'"); 
  }
  arg2 = reinterpret_cast< sword::SWKey * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_sword__SWKey, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SWModule_isLinked" "', argument " "3"" of type '" "sword::SWKey const *""'"); 
  }
  arg3 = reinterpret_cast< sword::SWKey * >(argp3);
  {
    try {
      result = (bool)((sword::SWModule const *)arg1)->isLinked((sword::SWKey const *)arg2,(sword::SWKey const *)arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWModule_hasEntry(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWModule *arg1 = 0 ;
  sword::SWKey *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SWModule_hasEntry", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWModule_hasEntry" "', argument " "1"" of type '" "sword::SWModule const *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWModule * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_sword__SWKey, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SWModule_hasEntry" "', argument " "2"" of type '" "sword::SWKey const *""'"); 
  }
  arg2 = reinterpret_cast< sword::SWKey * >(argp2);
  {
    try {
      result = (bool)((sword::SWModule const *)arg1)->hasEntry((sword::SWKey const *)arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWModule_setProcessEntryAttributes(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWModule *arg1 = 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SWModule_setProcessEntryAttributes", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWModule_setProcessEntryAttributes" "', argument " "1"" of type '" "sword::SWModule const *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWModule * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SWModule_setProcessEntryAttributes" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    try {
      ((sword::SWModule const *)arg1)->setProcessEntryAttributes(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWModule_isProcessEntryAttributes(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWModule *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWModule_isProcessEntryAttributes" "', argument " "1"" of type '" "sword::SWModule const *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWModule * >(argp1);
  {
    try {
      result = (bool)((sword::SWModule const *)arg1)->isProcessEntryAttributes(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWModule_deleteSearchFramework(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWModule *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWModule_deleteSearchFramework" "', argument " "1"" of type '" "sword::SWModule *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWModule * >(argp1);
  {
    try {
      (arg1)->deleteSearchFramework(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWModule_hasSearchFramework(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWModule *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWModule_hasSearchFramework" "', argument " "1"" of type '" "sword::SWModule *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWModule * >(argp1);
  {
    try {
      result = (bool)(arg1)->hasSearchFramework(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWModule___lshift____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::SWModule *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  sword::SWModule *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWModule___lshift__" "', argument " "1"" of type '" "sword::SWModule *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWModule * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SWModule___lshift__" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    try {
      result = (sword::SWModule *) &(arg1)->operator <<((char const *)arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__SWModule, 0 |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SWModule___lshift____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::SWModule *arg1 = 0 ;
  sword::SWKey *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  sword::SWModule *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWModule___lshift__" "', argument " "1"" of type '" "sword::SWModule *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWModule * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_sword__SWKey, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SWModule___lshift__" "', argument " "2"" of type '" "sword::SWKey const *""'"); 
  }
  arg2 = reinterpret_cast< sword::SWKey * >(argp2);
  {
    try {
      result = (sword::SWModule *) &(arg1)->operator <<((sword::SWKey const *)arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__SWModule, 0 |  0 );
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SWModule___lshift__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SWModule___lshift__", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__SWModule, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_sword__SWKey, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SWModule___lshift____SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__SWModule, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SWModule___lshift____SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SWModule___isub__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWModule *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  sword::SWModule *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SWModule___isub__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWModule, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWModule___isub__" "', argument " "1"" of type '" "sword::SWModule *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWModule * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SWModule___isub__" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    try {
      result = (sword::SWModule *) &(arg1)->operator -=(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__SWModule, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWModule___iadd__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWModule *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  sword::SWModule *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SWModule___iadd__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWModule, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWModule___iadd__" "', argument " "1"" of type '" "sword::SWModule *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWModule * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SWModule___iadd__" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    try {
      result = (sword::SWModule *) &(arg1)->operator +=(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__SWModule, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWModule_castTo(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWSearchable *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  sword::SWModule *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWSearchable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWModule_castTo" "', argument " "1"" of type '" "sword::SWSearchable *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWSearchable * >(argp1);
  {
    try {
      result = (sword::SWModule *)sword_SWModule_castTo(arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__SWModule, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWModule_getEntryAttributesMap(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWModule *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::map< sword::SWBuf,std::map< sword::SWBuf,AttributeValueMap,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,AttributeValueMap > > >,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,std::map< sword::SWBuf,AttributeValueMap,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,AttributeValueMap > > > > > > *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWModule_getEntryAttributesMap" "', argument " "1"" of type '" "sword::SWModule *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWModule * >(argp1);
  {
    try {
      result = (std::map< sword::SWBuf,std::map< sword::SWBuf,AttributeValueMap,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,AttributeValueMap > > >,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,std::map< sword::SWBuf,AttributeValueMap,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,AttributeValueMap > > > > > > *) &sword_SWModule_getEntryAttributesMap(arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__mapT_sword__SWBuf_AttributeListMap_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWModule_getConfigMap(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWModule *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWModule_getConfigMap" "', argument " "1"" of type '" "sword::SWModule *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWModule * >(argp1);
  {
    try {
      result = (std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > *)sword_SWModule_getConfigMap(arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__mapT_sword__SWBuf_sword__SWBuf_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SWModule_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_sword__SWModule, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN int Swig_var_SWMgr_MODTYPE_BIBLES_set(PyObject *_val) {
  {
    char *cptr = 0; size_t csize = 0; int alloc = SWIG_NEWOBJ;
    int res = SWIG_AsCharPtrAndSize(_val, &cptr, &csize, &alloc);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in variable '""sword::SWMgr::MODTYPE_BIBLES""' of type '""char const *""'");
    }
    if (alloc == SWIG_NEWOBJ) {
      sword::SWMgr::MODTYPE_BIBLES = cptr;
    } else {
      sword::SWMgr::MODTYPE_BIBLES = csize ? (char const *)reinterpret_cast< char* >(memcpy(new char[csize], cptr, sizeof(char)*(csize))) : 0;
    }
  }
  return 0;
fail:
  return 1;
}


SWIGINTERN PyObject *Swig_var_SWMgr_MODTYPE_BIBLES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(sword::SWMgr::MODTYPE_BIBLES);
  return pyobj;
}


SWIGINTERN PyObject *_wrap_SWMgr_MODTYPE_BIBLES_get(PyObject *SWIGUNUSEDPARM(self), PyObject *SWIGUNUSEDPARM(args)) {
  return Swig_var_SWMgr_MODTYPE_BIBLES_get();
}


SWIGINTERN PyObject *_wrap_SWMgr_MODTYPE_BIBLES_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  int res;
  
  res = Swig_var_SWMgr_MODTYPE_BIBLES_set(args);
  return !res ? SWIG_Py_Void() : NULL;
}


SWIGINTERN int Swig_var_SWMgr_MODTYPE_COMMENTARIES_set(PyObject *_val) {
  {
    char *cptr = 0; size_t csize = 0; int alloc = SWIG_NEWOBJ;
    int res = SWIG_AsCharPtrAndSize(_val, &cptr, &csize, &alloc);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in variable '""sword::SWMgr::MODTYPE_COMMENTARIES""' of type '""char const *""'");
    }
    if (alloc == SWIG_NEWOBJ) {
      sword::SWMgr::MODTYPE_COMMENTARIES = cptr;
    } else {
      sword::SWMgr::MODTYPE_COMMENTARIES = csize ? (char const *)reinterpret_cast< char* >(memcpy(new char[csize], cptr, sizeof(char)*(csize))) : 0;
    }
  }
  return 0;
fail:
  return 1;
}


SWIGINTERN PyObject *Swig_var_SWMgr_MODTYPE_COMMENTARIES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(sword::SWMgr::MODTYPE_COMMENTARIES);
  return pyobj;
}


SWIGINTERN PyObject *_wrap_SWMgr_MODTYPE_COMMENTARIES_get(PyObject *SWIGUNUSEDPARM(self), PyObject *SWIGUNUSEDPARM(args)) {
  return Swig_var_SWMgr_MODTYPE_COMMENTARIES_get();
}


SWIGINTERN PyObject *_wrap_SWMgr_MODTYPE_COMMENTARIES_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  int res;
  
  res = Swig_var_SWMgr_MODTYPE_COMMENTARIES_set(args);
  return !res ? SWIG_Py_Void() : NULL;
}


SWIGINTERN int Swig_var_SWMgr_MODTYPE_LEXDICTS_set(PyObject *_val) {
  {
    char *cptr = 0; size_t csize = 0; int alloc = SWIG_NEWOBJ;
    int res = SWIG_AsCharPtrAndSize(_val, &cptr, &csize, &alloc);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in variable '""sword::SWMgr::MODTYPE_LEXDICTS""' of type '""char const *""'");
    }
    if (alloc == SWIG_NEWOBJ) {
      sword::SWMgr::MODTYPE_LEXDICTS = cptr;
    } else {
      sword::SWMgr::MODTYPE_LEXDICTS = csize ? (char const *)reinterpret_cast< char* >(memcpy(new char[csize], cptr, sizeof(char)*(csize))) : 0;
    }
  }
  return 0;
fail:
  return 1;
}


SWIGINTERN PyObject *Swig_var_SWMgr_MODTYPE_LEXDICTS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(sword::SWMgr::MODTYPE_LEXDICTS);
  return pyobj;
}


SWIGINTERN PyObject *_wrap_SWMgr_MODTYPE_LEXDICTS_get(PyObject *SWIGUNUSEDPARM(self), PyObject *SWIGUNUSEDPARM(args)) {
  return Swig_var_SWMgr_MODTYPE_LEXDICTS_get();
}


SWIGINTERN PyObject *_wrap_SWMgr_MODTYPE_LEXDICTS_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  int res;
  
  res = Swig_var_SWMgr_MODTYPE_LEXDICTS_set(args);
  return !res ? SWIG_Py_Void() : NULL;
}


SWIGINTERN int Swig_var_SWMgr_MODTYPE_GENBOOKS_set(PyObject *_val) {
  {
    char *cptr = 0; size_t csize = 0; int alloc = SWIG_NEWOBJ;
    int res = SWIG_AsCharPtrAndSize(_val, &cptr, &csize, &alloc);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in variable '""sword::SWMgr::MODTYPE_GENBOOKS""' of type '""char const *""'");
    }
    if (alloc == SWIG_NEWOBJ) {
      sword::SWMgr::MODTYPE_GENBOOKS = cptr;
    } else {
      sword::SWMgr::MODTYPE_GENBOOKS = csize ? (char const *)reinterpret_cast< char* >(memcpy(new char[csize], cptr, sizeof(char)*(csize))) : 0;
    }
  }
  return 0;
fail:
  return 1;
}


SWIGINTERN PyObject *Swig_var_SWMgr_MODTYPE_GENBOOKS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(sword::SWMgr::MODTYPE_GENBOOKS);
  return pyobj;
}


SWIGINTERN PyObject *_wrap_SWMgr_MODTYPE_GENBOOKS_get(PyObject *SWIGUNUSEDPARM(self), PyObject *SWIGUNUSEDPARM(args)) {
  return Swig_var_SWMgr_MODTYPE_GENBOOKS_get();
}


SWIGINTERN PyObject *_wrap_SWMgr_MODTYPE_GENBOOKS_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  int res;
  
  res = Swig_var_SWMgr_MODTYPE_GENBOOKS_set(args);
  return !res ? SWIG_Py_Void() : NULL;
}


SWIGINTERN int Swig_var_SWMgr_MODTYPE_DAILYDEVOS_set(PyObject *_val) {
  {
    char *cptr = 0; size_t csize = 0; int alloc = SWIG_NEWOBJ;
    int res = SWIG_AsCharPtrAndSize(_val, &cptr, &csize, &alloc);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in variable '""sword::SWMgr::MODTYPE_DAILYDEVOS""' of type '""char const *""'");
    }
    if (alloc == SWIG_NEWOBJ) {
      sword::SWMgr::MODTYPE_DAILYDEVOS = cptr;
    } else {
      sword::SWMgr::MODTYPE_DAILYDEVOS = csize ? (char const *)reinterpret_cast< char* >(memcpy(new char[csize], cptr, sizeof(char)*(csize))) : 0;
    }
  }
  return 0;
fail:
  return 1;
}


SWIGINTERN PyObject *Swig_var_SWMgr_MODTYPE_DAILYDEVOS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(sword::SWMgr::MODTYPE_DAILYDEVOS);
  return pyobj;
}


SWIGINTERN PyObject *_wrap_SWMgr_MODTYPE_DAILYDEVOS_get(PyObject *SWIGUNUSEDPARM(self), PyObject *SWIGUNUSEDPARM(args)) {
  return Swig_var_SWMgr_MODTYPE_DAILYDEVOS_get();
}


SWIGINTERN PyObject *_wrap_SWMgr_MODTYPE_DAILYDEVOS_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  int res;
  
  res = Swig_var_SWMgr_MODTYPE_DAILYDEVOS_set(args);
  return !res ? SWIG_Py_Void() : NULL;
}


SWIGINTERN int Swig_var_SWMgr_isICU_set(PyObject *_val) {
  {
    bool val;
    int res = SWIG_AsVal_bool(_val, &val);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in variable '""sword::SWMgr::isICU""' of type '""bool""'");
    }
    sword::SWMgr::isICU = static_cast< bool >(val);
  }
  return 0;
fail:
  return 1;
}


SWIGINTERN PyObject *Swig_var_SWMgr_isICU_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_bool(static_cast< bool >(sword::SWMgr::isICU));
  return pyobj;
}


SWIGINTERN PyObject *_wrap_SWMgr_isICU_get(PyObject *SWIGUNUSEDPARM(self), PyObject *SWIGUNUSEDPARM(args)) {
  return Swig_var_SWMgr_isICU_get();
}


SWIGINTERN PyObject *_wrap_SWMgr_isICU_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  int res;
  
  res = Swig_var_SWMgr_isICU_set(args);
  return !res ? SWIG_Py_Void() : NULL;
}


SWIGINTERN int Swig_var_SWMgr_globalConfPath_set(PyObject *_val) {
  {
    char *cptr = 0; size_t csize = 0; int alloc = SWIG_NEWOBJ;
    int res = SWIG_AsCharPtrAndSize(_val, &cptr, &csize, &alloc);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in variable '""sword::SWMgr::globalConfPath""' of type '""char const *""'");
    }
    if (alloc == SWIG_NEWOBJ) {
      sword::SWMgr::globalConfPath = cptr;
    } else {
      sword::SWMgr::globalConfPath = csize ? (char const *)reinterpret_cast< char* >(memcpy(new char[csize], cptr, sizeof(char)*(csize))) : 0;
    }
  }
  return 0;
fail:
  return 1;
}


SWIGINTERN PyObject *Swig_var_SWMgr_globalConfPath_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(sword::SWMgr::globalConfPath);
  return pyobj;
}


SWIGINTERN PyObject *_wrap_SWMgr_globalConfPath_get(PyObject *SWIGUNUSEDPARM(self), PyObject *SWIGUNUSEDPARM(args)) {
  return Swig_var_SWMgr_globalConfPath_get();
}


SWIGINTERN PyObject *_wrap_SWMgr_globalConfPath_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  int res;
  
  res = Swig_var_SWMgr_globalConfPath_set(args);
  return !res ? SWIG_Py_Void() : NULL;
}


SWIGINTERN PyObject *_wrap_SWMgr_config_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWMgr *arg1 = 0 ;
  sword::SWConfig *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SWMgr_config_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWMgr, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWMgr_config_set" "', argument " "1"" of type '" "sword::SWMgr *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWMgr * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_sword__SWConfig, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SWMgr_config_set" "', argument " "2"" of type '" "sword::SWConfig *""'"); 
  }
  arg2 = reinterpret_cast< sword::SWConfig * >(argp2);
  if (arg1) (arg1)->config = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWMgr_config_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWMgr *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  sword::SWConfig *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWMgr, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWMgr_config_get" "', argument " "1"" of type '" "sword::SWMgr *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWMgr * >(argp1);
  result = (sword::SWConfig *) ((arg1)->config);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__SWConfig, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWMgr_sysConfig_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWMgr *arg1 = 0 ;
  sword::SWConfig *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SWMgr_sysConfig_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWMgr, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWMgr_sysConfig_set" "', argument " "1"" of type '" "sword::SWMgr *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWMgr * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_sword__SWConfig, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SWMgr_sysConfig_set" "', argument " "2"" of type '" "sword::SWConfig *""'"); 
  }
  arg2 = reinterpret_cast< sword::SWConfig * >(argp2);
  if (arg1) (arg1)->sysConfig = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWMgr_sysConfig_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWMgr *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  sword::SWConfig *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWMgr, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWMgr_sysConfig_get" "', argument " "1"" of type '" "sword::SWMgr *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWMgr * >(argp1);
  result = (sword::SWConfig *) ((arg1)->sysConfig);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__SWConfig, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWMgr_prefixPath_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWMgr *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SWMgr_prefixPath_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWMgr, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWMgr_prefixPath_set" "', argument " "1"" of type '" "sword::SWMgr *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWMgr * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SWMgr_prefixPath_set" "', argument " "2"" of type '" "char *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  delete[] arg1->prefixPath;
  if (arg2) {
    size_t size = strlen(reinterpret_cast< const char * >(arg2)) + 1;
    arg1->prefixPath = (char *)reinterpret_cast< char* >(memcpy(new char[size], reinterpret_cast< const char * >(arg2), sizeof(char)*(size)));
  } else {
    arg1->prefixPath = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWMgr_prefixPath_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWMgr *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWMgr, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWMgr_prefixPath_get" "', argument " "1"" of type '" "sword::SWMgr *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWMgr * >(argp1);
  result = (char *) ((arg1)->prefixPath);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWMgr_configPath_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWMgr *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SWMgr_configPath_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWMgr, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWMgr_configPath_set" "', argument " "1"" of type '" "sword::SWMgr *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWMgr * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SWMgr_configPath_set" "', argument " "2"" of type '" "char *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  delete[] arg1->configPath;
  if (arg2) {
    size_t size = strlen(reinterpret_cast< const char * >(arg2)) + 1;
    arg1->configPath = (char *)reinterpret_cast< char* >(memcpy(new char[size], reinterpret_cast< const char * >(arg2), sizeof(char)*(size)));
  } else {
    arg1->configPath = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWMgr_configPath_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWMgr *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWMgr, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWMgr_configPath_get" "', argument " "1"" of type '" "sword::SWMgr *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWMgr * >(argp1);
  result = (char *) ((arg1)->configPath);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWMgr_getModules__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::SWMgr *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  sword::ModMap *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWMgr, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWMgr_getModules" "', argument " "1"" of type '" "sword::SWMgr *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWMgr * >(argp1);
  {
    try {
      result = (sword::ModMap *) &(arg1)->getModules(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__mapT_sword__SWBuf_sword__SWModule_p_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWMgr_getModules__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::SWMgr *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  sword::ModMap *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWMgr, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWMgr_getModules" "', argument " "1"" of type '" "sword::SWMgr const *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWMgr * >(argp1);
  {
    try {
      result = (sword::ModMap *) &((sword::SWMgr const *)arg1)->getModules(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = swig::from(static_cast< std::map< sword::SWBuf,sword::SWModule *,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWModule * > > > >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWMgr_getModules(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SWMgr_getModules", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__SWMgr, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SWMgr_getModules__SWIG_0(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__SWMgr, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SWMgr_getModules__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SWMgr_getModules'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    sword::SWMgr::getModules()\n"
    "    sword::SWMgr::getModules() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SWMgr_getUtilModules__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::SWMgr *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  sword::ModMap *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWMgr, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWMgr_getUtilModules" "', argument " "1"" of type '" "sword::SWMgr *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWMgr * >(argp1);
  {
    try {
      result = (sword::ModMap *) &(arg1)->getUtilModules(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__mapT_sword__SWBuf_sword__SWModule_p_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWMgr_getUtilModules__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::SWMgr *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  sword::ModMap *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWMgr, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWMgr_getUtilModules" "', argument " "1"" of type '" "sword::SWMgr const *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWMgr * >(argp1);
  {
    try {
      result = (sword::ModMap *) &((sword::SWMgr const *)arg1)->getUtilModules(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = swig::from(static_cast< std::map< sword::SWBuf,sword::SWModule *,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWModule * > > > >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWMgr_getUtilModules(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SWMgr_getUtilModules", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__SWMgr, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SWMgr_getUtilModules__SWIG_0(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__SWMgr, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SWMgr_getUtilModules__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SWMgr_getUtilModules'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    sword::SWMgr::getUtilModules()\n"
    "    sword::SWMgr::getUtilModules() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SWMgr_getModule__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::SWMgr *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  sword::SWModule *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWMgr, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWMgr_getModule" "', argument " "1"" of type '" "sword::SWMgr *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWMgr * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SWMgr_getModule" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    try {
      result = (sword::SWModule *)(arg1)->getModule((char const *)arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__SWModule, 0 |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWMgr_getModule__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::SWMgr *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  sword::SWModule *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWMgr, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWMgr_getModule" "', argument " "1"" of type '" "sword::SWMgr const *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWMgr * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SWMgr_getModule" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    try {
      result = (sword::SWModule *)((sword::SWMgr const *)arg1)->getModule((char const *)arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__SWModule, 0 |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWMgr_getModule(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SWMgr_getModule", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__SWMgr, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SWMgr_getModule__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__SWMgr, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SWMgr_getModule__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SWMgr_getModule'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    sword::SWMgr::getModule(char const *)\n"
    "    sword::SWMgr::getModule(char const *) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_new_SWMgr__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::SWConfig *arg1 = 0 ;
  sword::SWConfig *arg2 = 0 ;
  bool arg3 ;
  sword::SWFilterMgr *arg4 = 0 ;
  bool arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  sword::SWMgr *result = 0 ;
  
  (void)self;
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWConfig, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SWMgr" "', argument " "1"" of type '" "sword::SWConfig *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWConfig * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_sword__SWConfig, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_SWMgr" "', argument " "2"" of type '" "sword::SWConfig *""'"); 
  }
  arg2 = reinterpret_cast< sword::SWConfig * >(argp2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SWMgr" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_sword__SWFilterMgr, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_SWMgr" "', argument " "4"" of type '" "sword::SWFilterMgr *""'"); 
  }
  arg4 = reinterpret_cast< sword::SWFilterMgr * >(argp4);
  ecode5 = SWIG_AsVal_bool(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_SWMgr" "', argument " "5"" of type '" "bool""'");
  } 
  arg5 = static_cast< bool >(val5);
  {
    try {
      result = (sword::SWMgr *)new sword::SWMgr(arg1,arg2,arg3,arg4,arg5); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__SWMgr, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SWMgr__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::SWConfig *arg1 = 0 ;
  sword::SWConfig *arg2 = 0 ;
  bool arg3 ;
  sword::SWFilterMgr *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  sword::SWMgr *result = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWConfig, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SWMgr" "', argument " "1"" of type '" "sword::SWConfig *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWConfig * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_sword__SWConfig, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_SWMgr" "', argument " "2"" of type '" "sword::SWConfig *""'"); 
  }
  arg2 = reinterpret_cast< sword::SWConfig * >(argp2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SWMgr" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_sword__SWFilterMgr, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_SWMgr" "', argument " "4"" of type '" "sword::SWFilterMgr *""'"); 
  }
  arg4 = reinterpret_cast< sword::SWFilterMgr * >(argp4);
  {
    try {
      result = (sword::SWMgr *)new sword::SWMgr(arg1,arg2,arg3,arg4); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__SWMgr, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SWMgr__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::SWConfig *arg1 = 0 ;
  sword::SWConfig *arg2 = 0 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  sword::SWMgr *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWConfig, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SWMgr" "', argument " "1"" of type '" "sword::SWConfig *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWConfig * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_sword__SWConfig, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_SWMgr" "', argument " "2"" of type '" "sword::SWConfig *""'"); 
  }
  arg2 = reinterpret_cast< sword::SWConfig * >(argp2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SWMgr" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    try {
      result = (sword::SWMgr *)new sword::SWMgr(arg1,arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__SWMgr, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SWMgr__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::SWConfig *arg1 = 0 ;
  sword::SWConfig *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  sword::SWMgr *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWConfig, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SWMgr" "', argument " "1"" of type '" "sword::SWConfig *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWConfig * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_sword__SWConfig, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_SWMgr" "', argument " "2"" of type '" "sword::SWConfig *""'"); 
  }
  arg2 = reinterpret_cast< sword::SWConfig * >(argp2);
  {
    try {
      result = (sword::SWMgr *)new sword::SWMgr(arg1,arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__SWMgr, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SWMgr__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::SWConfig *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  sword::SWMgr *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWConfig, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SWMgr" "', argument " "1"" of type '" "sword::SWConfig *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWConfig * >(argp1);
  {
    try {
      result = (sword::SWMgr *)new sword::SWMgr(arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__SWMgr, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SWMgr__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  sword::SWMgr *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (sword::SWMgr *)new sword::SWMgr(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__SWMgr, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SWMgr__SWIG_6(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::SWFilterMgr *arg1 = 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  sword::SWMgr *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWFilterMgr, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SWMgr" "', argument " "1"" of type '" "sword::SWFilterMgr *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWFilterMgr * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SWMgr" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    try {
      result = (sword::SWMgr *)new sword::SWMgr(arg1,arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__SWMgr, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SWMgr__SWIG_7(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::SWFilterMgr *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  sword::SWMgr *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWFilterMgr, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SWMgr" "', argument " "1"" of type '" "sword::SWFilterMgr *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWFilterMgr * >(argp1);
  {
    try {
      result = (sword::SWMgr *)new sword::SWMgr(arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__SWMgr, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SWMgr__SWIG_8(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  bool arg2 ;
  sword::SWFilterMgr *arg3 = 0 ;
  bool arg4 ;
  bool arg5 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  sword::SWMgr *result = 0 ;
  
  (void)self;
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SWMgr" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SWMgr" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_sword__SWFilterMgr, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_SWMgr" "', argument " "3"" of type '" "sword::SWFilterMgr *""'"); 
  }
  arg3 = reinterpret_cast< sword::SWFilterMgr * >(argp3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SWMgr" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  ecode5 = SWIG_AsVal_bool(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_SWMgr" "', argument " "5"" of type '" "bool""'");
  } 
  arg5 = static_cast< bool >(val5);
  {
    try {
      result = (sword::SWMgr *)new sword::SWMgr((char const *)arg1,arg2,arg3,arg4,arg5); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__SWMgr, SWIG_POINTER_NEW |  0 );
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SWMgr__SWIG_9(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  bool arg2 ;
  sword::SWFilterMgr *arg3 = 0 ;
  bool arg4 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  sword::SWMgr *result = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SWMgr" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SWMgr" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_sword__SWFilterMgr, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_SWMgr" "', argument " "3"" of type '" "sword::SWFilterMgr *""'"); 
  }
  arg3 = reinterpret_cast< sword::SWFilterMgr * >(argp3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SWMgr" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  {
    try {
      result = (sword::SWMgr *)new sword::SWMgr((char const *)arg1,arg2,arg3,arg4); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__SWMgr, SWIG_POINTER_NEW |  0 );
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SWMgr__SWIG_10(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  bool arg2 ;
  sword::SWFilterMgr *arg3 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  sword::SWMgr *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SWMgr" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SWMgr" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_sword__SWFilterMgr, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_SWMgr" "', argument " "3"" of type '" "sword::SWFilterMgr *""'"); 
  }
  arg3 = reinterpret_cast< sword::SWFilterMgr * >(argp3);
  {
    try {
      result = (sword::SWMgr *)new sword::SWMgr((char const *)arg1,arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__SWMgr, SWIG_POINTER_NEW |  0 );
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SWMgr__SWIG_11(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  bool arg2 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  sword::SWMgr *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SWMgr" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SWMgr" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    try {
      result = (sword::SWMgr *)new sword::SWMgr((char const *)arg1,arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__SWMgr, SWIG_POINTER_NEW |  0 );
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SWMgr__SWIG_12(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  sword::SWMgr *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SWMgr" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  {
    try {
      result = (sword::SWMgr *)new sword::SWMgr((char const *)arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__SWMgr, SWIG_POINTER_NEW |  0 );
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SWMgr(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SWMgr", 0, 5, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_SWMgr__SWIG_5(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__SWConfig, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SWMgr__SWIG_4(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__SWFilterMgr, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SWMgr__SWIG_7(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SWMgr__SWIG_12(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__SWConfig, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_sword__SWConfig, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_SWMgr__SWIG_3(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__SWFilterMgr, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_SWMgr__SWIG_6(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_SWMgr__SWIG_11(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__SWConfig, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_sword__SWConfig, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_SWMgr__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_sword__SWFilterMgr, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_new_SWMgr__SWIG_10(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__SWConfig, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_sword__SWConfig, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_sword__SWFilterMgr, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_new_SWMgr__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_sword__SWFilterMgr, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_new_SWMgr__SWIG_9(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__SWConfig, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_sword__SWConfig, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_sword__SWFilterMgr, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_bool(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_new_SWMgr__SWIG_0(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_sword__SWFilterMgr, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_bool(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_new_SWMgr__SWIG_8(self, argc, argv);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SWMgr'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    sword::SWMgr::SWMgr(sword::SWConfig *,sword::SWConfig *,bool,sword::SWFilterMgr *,bool)\n"
    "    sword::SWMgr::SWMgr(sword::SWConfig *,sword::SWConfig *,bool,sword::SWFilterMgr *)\n"
    "    sword::SWMgr::SWMgr(sword::SWConfig *,sword::SWConfig *,bool)\n"
    "    sword::SWMgr::SWMgr(sword::SWConfig *,sword::SWConfig *)\n"
    "    sword::SWMgr::SWMgr(sword::SWConfig *)\n"
    "    sword::SWMgr::SWMgr()\n"
    "    sword::SWMgr::SWMgr(sword::SWFilterMgr *,bool)\n"
    "    sword::SWMgr::SWMgr(sword::SWFilterMgr *)\n"
    "    sword::SWMgr::SWMgr(char const *,bool,sword::SWFilterMgr *,bool,bool)\n"
    "    sword::SWMgr::SWMgr(char const *,bool,sword::SWFilterMgr *,bool)\n"
    "    sword::SWMgr::SWMgr(char const *,bool,sword::SWFilterMgr *)\n"
    "    sword::SWMgr::SWMgr(char const *,bool)\n"
    "    sword::SWMgr::SWMgr(char const *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SWMgr(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWMgr *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWMgr, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SWMgr" "', argument " "1"" of type '" "sword::SWMgr *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWMgr * >(argp1);
  {
    try {
      delete arg1; 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWMgr_augmentModules__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::SWMgr *arg1 = 0 ;
  char *arg2 = 0 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWMgr, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWMgr_augmentModules" "', argument " "1"" of type '" "sword::SWMgr *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWMgr * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SWMgr_augmentModules" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SWMgr_augmentModules" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    try {
      (arg1)->augmentModules((char const *)arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWMgr_augmentModules__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::SWMgr *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWMgr, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWMgr_augmentModules" "', argument " "1"" of type '" "sword::SWMgr *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWMgr * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SWMgr_augmentModules" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    try {
      (arg1)->augmentModules((char const *)arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWMgr_augmentModules(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SWMgr_augmentModules", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__SWMgr, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SWMgr_augmentModules__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__SWMgr, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SWMgr_augmentModules__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SWMgr_augmentModules'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    sword::SWMgr::augmentModules(char const *,bool)\n"
    "    sword::SWMgr::augmentModules(char const *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SWMgr_deleteModule(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWMgr *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SWMgr_deleteModule", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWMgr, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWMgr_deleteModule" "', argument " "1"" of type '" "sword::SWMgr *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWMgr * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SWMgr_deleteModule" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    try {
      (arg1)->deleteModule((char const *)arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWMgr_InstallScan(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWMgr *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SWMgr_InstallScan", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWMgr, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWMgr_InstallScan" "', argument " "1"" of type '" "sword::SWMgr *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWMgr * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SWMgr_InstallScan" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    try {
      (arg1)->InstallScan((char const *)arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWMgr_load(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWMgr *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  signed char result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWMgr, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWMgr_load" "', argument " "1"" of type '" "sword::SWMgr *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWMgr * >(argp1);
  {
    try {
      result = (signed char)(arg1)->load(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_signed_SS_char(static_cast< signed char >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWMgr_setGlobalOption(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWMgr *arg1 = 0 ;
  char *arg2 = 0 ;
  char *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SWMgr_setGlobalOption", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWMgr, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWMgr_setGlobalOption" "', argument " "1"" of type '" "sword::SWMgr *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWMgr * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SWMgr_setGlobalOption" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SWMgr_setGlobalOption" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  {
    try {
      (arg1)->setGlobalOption((char const *)arg2,(char const *)arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWMgr_getGlobalOption(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWMgr *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  char *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SWMgr_getGlobalOption", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWMgr, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWMgr_getGlobalOption" "', argument " "1"" of type '" "sword::SWMgr *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWMgr * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SWMgr_getGlobalOption" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    try {
      result = (char *)(arg1)->getGlobalOption((char const *)arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWMgr_getGlobalOptionTip(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWMgr *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  char *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SWMgr_getGlobalOptionTip", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWMgr, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWMgr_getGlobalOptionTip" "', argument " "1"" of type '" "sword::SWMgr *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWMgr * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SWMgr_getGlobalOptionTip" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    try {
      result = (char *)(arg1)->getGlobalOptionTip((char const *)arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWMgr_getGlobalOptions(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWMgr *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  sword::StringList result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWMgr, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWMgr_getGlobalOptions" "', argument " "1"" of type '" "sword::SWMgr *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWMgr * >(argp1);
  {
    try {
      result = (arg1)->getGlobalOptions(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = swig::from(static_cast< std::list< sword::SWBuf,std::allocator< sword::SWBuf > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWMgr_getGlobalOptionValues(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWMgr *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  sword::StringList result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SWMgr_getGlobalOptionValues", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWMgr, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWMgr_getGlobalOptionValues" "', argument " "1"" of type '" "sword::SWMgr *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWMgr * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SWMgr_getGlobalOptionValues" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    try {
      result = (arg1)->getGlobalOptionValues((char const *)arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = swig::from(static_cast< std::list< sword::SWBuf,std::allocator< sword::SWBuf > > >(result));
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWMgr_filterText__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::SWMgr *arg1 = 0 ;
  char *arg2 = 0 ;
  sword::SWBuf *arg3 = 0 ;
  sword::SWKey *arg4 = 0 ;
  sword::SWModule *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  char result;
  
  (void)self;
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWMgr, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWMgr_filterText" "', argument " "1"" of type '" "sword::SWMgr *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWMgr * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SWMgr_filterText" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_sword__SWBuf,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SWMgr_filterText" "', argument " "3"" of type '" "sword::SWBuf &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SWMgr_filterText" "', argument " "3"" of type '" "sword::SWBuf &""'"); 
  }
  arg3 = reinterpret_cast< sword::SWBuf * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_sword__SWKey, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SWMgr_filterText" "', argument " "4"" of type '" "sword::SWKey const *""'"); 
  }
  arg4 = reinterpret_cast< sword::SWKey * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5,SWIGTYPE_p_sword__SWModule, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "SWMgr_filterText" "', argument " "5"" of type '" "sword::SWModule const *""'"); 
  }
  arg5 = reinterpret_cast< sword::SWModule * >(argp5);
  {
    try {
      result = (char)(arg1)->filterText((char const *)arg2,*arg3,(sword::SWKey const *)arg4,(sword::SWModule const *)arg5); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_char(static_cast< char >(result));
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWMgr_filterText__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::SWMgr *arg1 = 0 ;
  char *arg2 = 0 ;
  sword::SWBuf *arg3 = 0 ;
  sword::SWKey *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  char result;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWMgr, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWMgr_filterText" "', argument " "1"" of type '" "sword::SWMgr *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWMgr * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SWMgr_filterText" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_sword__SWBuf,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SWMgr_filterText" "', argument " "3"" of type '" "sword::SWBuf &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SWMgr_filterText" "', argument " "3"" of type '" "sword::SWBuf &""'"); 
  }
  arg3 = reinterpret_cast< sword::SWBuf * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_sword__SWKey, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SWMgr_filterText" "', argument " "4"" of type '" "sword::SWKey const *""'"); 
  }
  arg4 = reinterpret_cast< sword::SWKey * >(argp4);
  {
    try {
      result = (char)(arg1)->filterText((char const *)arg2,*arg3,(sword::SWKey const *)arg4); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_char(static_cast< char >(result));
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWMgr_filterText__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::SWMgr *arg1 = 0 ;
  char *arg2 = 0 ;
  sword::SWBuf *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  char result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWMgr, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWMgr_filterText" "', argument " "1"" of type '" "sword::SWMgr *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWMgr * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SWMgr_filterText" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_sword__SWBuf,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SWMgr_filterText" "', argument " "3"" of type '" "sword::SWBuf &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SWMgr_filterText" "', argument " "3"" of type '" "sword::SWBuf &""'"); 
  }
  arg3 = reinterpret_cast< sword::SWBuf * >(argp3);
  {
    try {
      result = (char)(arg1)->filterText((char const *)arg2,*arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_char(static_cast< char >(result));
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWMgr_filterText(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SWMgr_filterText", 0, 5, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__SWMgr, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_sword__SWBuf, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SWMgr_filterText__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__SWMgr, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_sword__SWBuf, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_sword__SWKey, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_SWMgr_filterText__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__SWMgr, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_sword__SWBuf, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_sword__SWKey, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_sword__SWModule, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_SWMgr_filterText__SWIG_0(self, argc, argv);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SWMgr_filterText'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    sword::SWMgr::filterText(char const *,sword::SWBuf &,sword::SWKey const *,sword::SWModule const *)\n"
    "    sword::SWMgr::filterText(char const *,sword::SWBuf &,sword::SWKey const *)\n"
    "    sword::SWMgr::filterText(char const *,sword::SWBuf &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SWMgr_setCipherKey(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWMgr *arg1 = 0 ;
  char *arg2 = 0 ;
  char *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  PyObject *swig_obj[3] ;
  signed char result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SWMgr_setCipherKey", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWMgr, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWMgr_setCipherKey" "', argument " "1"" of type '" "sword::SWMgr *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWMgr * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SWMgr_setCipherKey" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SWMgr_setCipherKey" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  {
    try {
      result = (signed char)(arg1)->setCipherKey((char const *)arg2,(char const *)arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_signed_SS_char(static_cast< signed char >(result));
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWMgr_getGlobalOptionsVector(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWMgr *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< sword::SWBuf,std::allocator< sword::SWBuf > > result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWMgr, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWMgr_getGlobalOptionsVector" "', argument " "1"" of type '" "sword::SWMgr *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWMgr * >(argp1);
  {
    try {
      result = sword_SWMgr_getGlobalOptionsVector(arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = swig::from(static_cast< std::vector< sword::SWBuf,std::allocator< sword::SWBuf > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWMgr_getGlobalOptionValuesVector(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWMgr *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  std::vector< sword::SWBuf,std::allocator< sword::SWBuf > > result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SWMgr_getGlobalOptionValuesVector", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWMgr, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWMgr_getGlobalOptionValuesVector" "', argument " "1"" of type '" "sword::SWMgr *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWMgr * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SWMgr_getGlobalOptionValuesVector" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    try {
      result = sword_SWMgr_getGlobalOptionValuesVector(arg1,(char const *)arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = swig::from(static_cast< std::vector< sword::SWBuf,std::allocator< sword::SWBuf > > >(result));
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWMgr_getModuleAt(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWMgr *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  sword::SWModule *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SWMgr_getModuleAt", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWMgr, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWMgr_getModuleAt" "', argument " "1"" of type '" "sword::SWMgr *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWMgr * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SWMgr_getModuleAt" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    try {
      result = (sword::SWModule *)sword_SWMgr_getModuleAt(arg1,arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__SWModule, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SWMgr_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_sword__SWMgr, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SWMgr_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_DirEntry_name_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::DirEntry *arg1 = 0 ;
  sword::SWBuf *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "DirEntry_name_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__DirEntry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DirEntry_name_set" "', argument " "1"" of type '" "sword::DirEntry *""'"); 
  }
  arg1 = reinterpret_cast< sword::DirEntry * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_sword__SWBuf, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DirEntry_name_set" "', argument " "2"" of type '" "sword::SWBuf *""'"); 
  }
  arg2 = reinterpret_cast< sword::SWBuf * >(argp2);
  if (arg1) (arg1)->name = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DirEntry_name_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::DirEntry *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  sword::SWBuf *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__DirEntry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DirEntry_name_get" "', argument " "1"" of type '" "sword::DirEntry *""'"); 
  }
  arg1 = reinterpret_cast< sword::DirEntry * >(argp1);
  result = (sword::SWBuf *)& ((arg1)->name);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__SWBuf, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DirEntry_size_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::DirEntry *arg1 = 0 ;
  unsigned long arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "DirEntry_size_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__DirEntry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DirEntry_size_set" "', argument " "1"" of type '" "sword::DirEntry *""'"); 
  }
  arg1 = reinterpret_cast< sword::DirEntry * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DirEntry_size_set" "', argument " "2"" of type '" "unsigned long""'");
  } 
  arg2 = static_cast< unsigned long >(val2);
  if (arg1) (arg1)->size = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DirEntry_size_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::DirEntry *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  unsigned long result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__DirEntry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DirEntry_size_get" "', argument " "1"" of type '" "sword::DirEntry *""'"); 
  }
  arg1 = reinterpret_cast< sword::DirEntry * >(argp1);
  result = (unsigned long) ((arg1)->size);
  resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DirEntry_isDirectory_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::DirEntry *arg1 = 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "DirEntry_isDirectory_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__DirEntry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DirEntry_isDirectory_set" "', argument " "1"" of type '" "sword::DirEntry *""'"); 
  }
  arg1 = reinterpret_cast< sword::DirEntry * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DirEntry_isDirectory_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->isDirectory = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DirEntry_isDirectory_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::DirEntry *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__DirEntry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DirEntry_isDirectory_get" "', argument " "1"" of type '" "sword::DirEntry *""'"); 
  }
  arg1 = reinterpret_cast< sword::DirEntry * >(argp1);
  result = (bool) ((arg1)->isDirectory);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DirEntry(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::DirEntry *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_DirEntry", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (sword::DirEntry *)new sword::DirEntry(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__DirEntry, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_DirEntry(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::DirEntry *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__DirEntry, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DirEntry" "', argument " "1"" of type '" "sword::DirEntry *""'"); 
  }
  arg1 = reinterpret_cast< sword::DirEntry * >(argp1);
  {
    try {
      delete arg1; 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *DirEntry_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_sword__DirEntry, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *DirEntry_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN int Swig_var_FileMgr_CREAT_set(PyObject *_val) {
  {
    unsigned int val;
    int res = SWIG_AsVal_unsigned_SS_int(_val, &val);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in variable '""sword::FileMgr::CREAT""' of type '""unsigned int""'");
    }
    sword::FileMgr::CREAT = static_cast< unsigned int >(val);
  }
  return 0;
fail:
  return 1;
}


SWIGINTERN PyObject *Swig_var_FileMgr_CREAT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(sword::FileMgr::CREAT));
  return pyobj;
}


SWIGINTERN PyObject *_wrap_FileMgr_CREAT_get(PyObject *SWIGUNUSEDPARM(self), PyObject *SWIGUNUSEDPARM(args)) {
  return Swig_var_FileMgr_CREAT_get();
}


SWIGINTERN PyObject *_wrap_FileMgr_CREAT_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  int res;
  
  res = Swig_var_FileMgr_CREAT_set(args);
  return !res ? SWIG_Py_Void() : NULL;
}


SWIGINTERN int Swig_var_FileMgr_APPEND_set(PyObject *_val) {
  {
    unsigned int val;
    int res = SWIG_AsVal_unsigned_SS_int(_val, &val);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in variable '""sword::FileMgr::APPEND""' of type '""unsigned int""'");
    }
    sword::FileMgr::APPEND = static_cast< unsigned int >(val);
  }
  return 0;
fail:
  return 1;
}


SWIGINTERN PyObject *Swig_var_FileMgr_APPEND_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(sword::FileMgr::APPEND));
  return pyobj;
}


SWIGINTERN PyObject *_wrap_FileMgr_APPEND_get(PyObject *SWIGUNUSEDPARM(self), PyObject *SWIGUNUSEDPARM(args)) {
  return Swig_var_FileMgr_APPEND_get();
}


SWIGINTERN PyObject *_wrap_FileMgr_APPEND_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  int res;
  
  res = Swig_var_FileMgr_APPEND_set(args);
  return !res ? SWIG_Py_Void() : NULL;
}


SWIGINTERN int Swig_var_FileMgr_TRUNC_set(PyObject *_val) {
  {
    unsigned int val;
    int res = SWIG_AsVal_unsigned_SS_int(_val, &val);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in variable '""sword::FileMgr::TRUNC""' of type '""unsigned int""'");
    }
    sword::FileMgr::TRUNC = static_cast< unsigned int >(val);
  }
  return 0;
fail:
  return 1;
}


SWIGINTERN PyObject *Swig_var_FileMgr_TRUNC_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(sword::FileMgr::TRUNC));
  return pyobj;
}


SWIGINTERN PyObject *_wrap_FileMgr_TRUNC_get(PyObject *SWIGUNUSEDPARM(self), PyObject *SWIGUNUSEDPARM(args)) {
  return Swig_var_FileMgr_TRUNC_get();
}


SWIGINTERN PyObject *_wrap_FileMgr_TRUNC_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  int res;
  
  res = Swig_var_FileMgr_TRUNC_set(args);
  return !res ? SWIG_Py_Void() : NULL;
}


SWIGINTERN int Swig_var_FileMgr_RDONLY_set(PyObject *_val) {
  {
    unsigned int val;
    int res = SWIG_AsVal_unsigned_SS_int(_val, &val);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in variable '""sword::FileMgr::RDONLY""' of type '""unsigned int""'");
    }
    sword::FileMgr::RDONLY = static_cast< unsigned int >(val);
  }
  return 0;
fail:
  return 1;
}


SWIGINTERN PyObject *Swig_var_FileMgr_RDONLY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(sword::FileMgr::RDONLY));
  return pyobj;
}


SWIGINTERN PyObject *_wrap_FileMgr_RDONLY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *SWIGUNUSEDPARM(args)) {
  return Swig_var_FileMgr_RDONLY_get();
}


SWIGINTERN PyObject *_wrap_FileMgr_RDONLY_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  int res;
  
  res = Swig_var_FileMgr_RDONLY_set(args);
  return !res ? SWIG_Py_Void() : NULL;
}


SWIGINTERN int Swig_var_FileMgr_RDWR_set(PyObject *_val) {
  {
    unsigned int val;
    int res = SWIG_AsVal_unsigned_SS_int(_val, &val);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in variable '""sword::FileMgr::RDWR""' of type '""unsigned int""'");
    }
    sword::FileMgr::RDWR = static_cast< unsigned int >(val);
  }
  return 0;
fail:
  return 1;
}


SWIGINTERN PyObject *Swig_var_FileMgr_RDWR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(sword::FileMgr::RDWR));
  return pyobj;
}


SWIGINTERN PyObject *_wrap_FileMgr_RDWR_get(PyObject *SWIGUNUSEDPARM(self), PyObject *SWIGUNUSEDPARM(args)) {
  return Swig_var_FileMgr_RDWR_get();
}


SWIGINTERN PyObject *_wrap_FileMgr_RDWR_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  int res;
  
  res = Swig_var_FileMgr_RDWR_set(args);
  return !res ? SWIG_Py_Void() : NULL;
}


SWIGINTERN int Swig_var_FileMgr_WRONLY_set(PyObject *_val) {
  {
    unsigned int val;
    int res = SWIG_AsVal_unsigned_SS_int(_val, &val);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in variable '""sword::FileMgr::WRONLY""' of type '""unsigned int""'");
    }
    sword::FileMgr::WRONLY = static_cast< unsigned int >(val);
  }
  return 0;
fail:
  return 1;
}


SWIGINTERN PyObject *Swig_var_FileMgr_WRONLY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(sword::FileMgr::WRONLY));
  return pyobj;
}


SWIGINTERN PyObject *_wrap_FileMgr_WRONLY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *SWIGUNUSEDPARM(args)) {
  return Swig_var_FileMgr_WRONLY_get();
}


SWIGINTERN PyObject *_wrap_FileMgr_WRONLY_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  int res;
  
  res = Swig_var_FileMgr_WRONLY_set(args);
  return !res ? SWIG_Py_Void() : NULL;
}


SWIGINTERN int Swig_var_FileMgr_IREAD_set(PyObject *_val) {
  {
    unsigned int val;
    int res = SWIG_AsVal_unsigned_SS_int(_val, &val);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in variable '""sword::FileMgr::IREAD""' of type '""unsigned int""'");
    }
    sword::FileMgr::IREAD = static_cast< unsigned int >(val);
  }
  return 0;
fail:
  return 1;
}


SWIGINTERN PyObject *Swig_var_FileMgr_IREAD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(sword::FileMgr::IREAD));
  return pyobj;
}


SWIGINTERN PyObject *_wrap_FileMgr_IREAD_get(PyObject *SWIGUNUSEDPARM(self), PyObject *SWIGUNUSEDPARM(args)) {
  return Swig_var_FileMgr_IREAD_get();
}


SWIGINTERN PyObject *_wrap_FileMgr_IREAD_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  int res;
  
  res = Swig_var_FileMgr_IREAD_set(args);
  return !res ? SWIG_Py_Void() : NULL;
}


SWIGINTERN int Swig_var_FileMgr_IWRITE_set(PyObject *_val) {
  {
    unsigned int val;
    int res = SWIG_AsVal_unsigned_SS_int(_val, &val);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in variable '""sword::FileMgr::IWRITE""' of type '""unsigned int""'");
    }
    sword::FileMgr::IWRITE = static_cast< unsigned int >(val);
  }
  return 0;
fail:
  return 1;
}


SWIGINTERN PyObject *Swig_var_FileMgr_IWRITE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(sword::FileMgr::IWRITE));
  return pyobj;
}


SWIGINTERN PyObject *_wrap_FileMgr_IWRITE_get(PyObject *SWIGUNUSEDPARM(self), PyObject *SWIGUNUSEDPARM(args)) {
  return Swig_var_FileMgr_IWRITE_get();
}


SWIGINTERN PyObject *_wrap_FileMgr_IWRITE_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  int res;
  
  res = Swig_var_FileMgr_IWRITE_set(args);
  return !res ? SWIG_Py_Void() : NULL;
}


SWIGINTERN PyObject *_wrap_FileMgr_maxFiles_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::FileMgr *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "FileMgr_maxFiles_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__FileMgr, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileMgr_maxFiles_set" "', argument " "1"" of type '" "sword::FileMgr *""'"); 
  }
  arg1 = reinterpret_cast< sword::FileMgr * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileMgr_maxFiles_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  if (arg1) (arg1)->maxFiles = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FileMgr_maxFiles_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::FileMgr *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__FileMgr, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileMgr_maxFiles_get" "', argument " "1"" of type '" "sword::FileMgr *""'"); 
  }
  arg1 = reinterpret_cast< sword::FileMgr * >(argp1);
  result = (int) ((arg1)->maxFiles);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FileMgr_getSystemFileMgr(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::FileMgr *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "FileMgr_getSystemFileMgr", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (sword::FileMgr *)sword::FileMgr::getSystemFileMgr(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__FileMgr, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FileMgr_setSystemFileMgr(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::FileMgr *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__FileMgr, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileMgr_setSystemFileMgr" "', argument " "1"" of type '" "sword::FileMgr *""'"); 
  }
  arg1 = reinterpret_cast< sword::FileMgr * >(argp1);
  {
    try {
      sword::FileMgr::setSystemFileMgr(arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FileMgr__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  sword::FileMgr *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FileMgr" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  {
    try {
      result = (sword::FileMgr *)new sword::FileMgr(arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__FileMgr, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FileMgr__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  sword::FileMgr *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (sword::FileMgr *)new sword::FileMgr(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__FileMgr, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FileMgr(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_FileMgr", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_FileMgr__SWIG_1(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_FileMgr__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_FileMgr'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    sword::FileMgr::FileMgr(int)\n"
    "    sword::FileMgr::FileMgr()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_FileMgr(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::FileMgr *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__FileMgr, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileMgr" "', argument " "1"" of type '" "sword::FileMgr *""'"); 
  }
  arg1 = reinterpret_cast< sword::FileMgr * >(argp1);
  {
    try {
      delete arg1; 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FileMgr_open__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::FileMgr *arg1 = 0 ;
  char *arg2 = 0 ;
  int arg3 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  sword::FileDesc *result = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__FileMgr, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileMgr_open" "', argument " "1"" of type '" "sword::FileMgr *""'"); 
  }
  arg1 = reinterpret_cast< sword::FileMgr * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileMgr_open" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileMgr_open" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FileMgr_open" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  {
    try {
      result = (sword::FileDesc *)(arg1)->open((char const *)arg2,arg3,arg4); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__FileDesc, 0 |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_FileMgr_open__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::FileMgr *arg1 = 0 ;
  char *arg2 = 0 ;
  unsigned int arg3 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  sword::FileDesc *result = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__FileMgr, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileMgr_open" "', argument " "1"" of type '" "sword::FileMgr *""'"); 
  }
  arg1 = reinterpret_cast< sword::FileMgr * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileMgr_open" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileMgr_open" "', argument " "3"" of type '" "unsigned int""'");
  } 
  arg3 = static_cast< unsigned int >(val3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FileMgr_open" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  {
    try {
      result = (sword::FileDesc *)(arg1)->open((char const *)arg2,arg3,arg4); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__FileDesc, 0 |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_FileMgr_open__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::FileMgr *arg1 = 0 ;
  char *arg2 = 0 ;
  unsigned int arg3 ;
  unsigned int arg4 ;
  bool arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  unsigned int val4 ;
  int ecode4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  sword::FileDesc *result = 0 ;
  
  (void)self;
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__FileMgr, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileMgr_open" "', argument " "1"" of type '" "sword::FileMgr *""'"); 
  }
  arg1 = reinterpret_cast< sword::FileMgr * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileMgr_open" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileMgr_open" "', argument " "3"" of type '" "unsigned int""'");
  } 
  arg3 = static_cast< unsigned int >(val3);
  ecode4 = SWIG_AsVal_unsigned_SS_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FileMgr_open" "', argument " "4"" of type '" "unsigned int""'");
  } 
  arg4 = static_cast< unsigned int >(val4);
  ecode5 = SWIG_AsVal_bool(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "FileMgr_open" "', argument " "5"" of type '" "bool""'");
  } 
  arg5 = static_cast< bool >(val5);
  {
    try {
      result = (sword::FileDesc *)(arg1)->open((char const *)arg2,arg3,arg4,arg5); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__FileDesc, 0 |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_FileMgr_open__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::FileMgr *arg1 = 0 ;
  char *arg2 = 0 ;
  unsigned int arg3 ;
  unsigned int arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  unsigned int val4 ;
  int ecode4 = 0 ;
  sword::FileDesc *result = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__FileMgr, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileMgr_open" "', argument " "1"" of type '" "sword::FileMgr *""'"); 
  }
  arg1 = reinterpret_cast< sword::FileMgr * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileMgr_open" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileMgr_open" "', argument " "3"" of type '" "unsigned int""'");
  } 
  arg3 = static_cast< unsigned int >(val3);
  ecode4 = SWIG_AsVal_unsigned_SS_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FileMgr_open" "', argument " "4"" of type '" "unsigned int""'");
  } 
  arg4 = static_cast< unsigned int >(val4);
  {
    try {
      result = (sword::FileDesc *)(arg1)->open((char const *)arg2,arg3,arg4); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__FileDesc, 0 |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_FileMgr_open__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::FileMgr *arg1 = 0 ;
  char *arg2 = 0 ;
  unsigned int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  sword::FileDesc *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__FileMgr, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileMgr_open" "', argument " "1"" of type '" "sword::FileMgr *""'"); 
  }
  arg1 = reinterpret_cast< sword::FileMgr * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileMgr_open" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileMgr_open" "', argument " "3"" of type '" "unsigned int""'");
  } 
  arg3 = static_cast< unsigned int >(val3);
  {
    try {
      result = (sword::FileDesc *)(arg1)->open((char const *)arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__FileDesc, 0 |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_FileMgr_open__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::FileMgr *arg1 = 0 ;
  char *arg2 = 0 ;
  int arg3 ;
  int arg4 ;
  bool arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  sword::FileDesc *result = 0 ;
  
  (void)self;
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__FileMgr, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileMgr_open" "', argument " "1"" of type '" "sword::FileMgr *""'"); 
  }
  arg1 = reinterpret_cast< sword::FileMgr * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileMgr_open" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileMgr_open" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FileMgr_open" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_bool(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "FileMgr_open" "', argument " "5"" of type '" "bool""'");
  } 
  arg5 = static_cast< bool >(val5);
  {
    try {
      result = (sword::FileDesc *)(arg1)->open((char const *)arg2,arg3,arg4,arg5); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__FileDesc, 0 |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_FileMgr_open__SWIG_6(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::FileMgr *arg1 = 0 ;
  char *arg2 = 0 ;
  int arg3 ;
  int arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  sword::FileDesc *result = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__FileMgr, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileMgr_open" "', argument " "1"" of type '" "sword::FileMgr *""'"); 
  }
  arg1 = reinterpret_cast< sword::FileMgr * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileMgr_open" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileMgr_open" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FileMgr_open" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  {
    try {
      result = (sword::FileDesc *)(arg1)->open((char const *)arg2,arg3,arg4); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__FileDesc, 0 |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_FileMgr_open__SWIG_7(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::FileMgr *arg1 = 0 ;
  char *arg2 = 0 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  sword::FileDesc *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__FileMgr, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileMgr_open" "', argument " "1"" of type '" "sword::FileMgr *""'"); 
  }
  arg1 = reinterpret_cast< sword::FileMgr * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileMgr_open" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileMgr_open" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  {
    try {
      result = (sword::FileDesc *)(arg1)->open((char const *)arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__FileDesc, 0 |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_FileMgr_open(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "FileMgr_open", 0, 5, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__FileMgr, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_FileMgr_open__SWIG_4(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__FileMgr, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_FileMgr_open__SWIG_7(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__FileMgr, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_FileMgr_open__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__FileMgr, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_unsigned_SS_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_FileMgr_open__SWIG_3(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__FileMgr, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_FileMgr_open__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__FileMgr, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_FileMgr_open__SWIG_6(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__FileMgr, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_unsigned_SS_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_bool(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_FileMgr_open__SWIG_2(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__FileMgr, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_bool(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_FileMgr_open__SWIG_5(self, argc, argv);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'FileMgr_open'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    sword::FileMgr::open(char const *,int,bool)\n"
    "    sword::FileMgr::open(char const *,unsigned int,bool)\n"
    "    sword::FileMgr::open(char const *,unsigned int,unsigned int,bool)\n"
    "    sword::FileMgr::open(char const *,unsigned int,unsigned int)\n"
    "    sword::FileMgr::open(char const *,unsigned int)\n"
    "    sword::FileMgr::open(char const *,int,int,bool)\n"
    "    sword::FileMgr::open(char const *,int,int)\n"
    "    sword::FileMgr::open(char const *,int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_FileMgr_close(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::FileMgr *arg1 = 0 ;
  sword::FileDesc *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "FileMgr_close", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__FileMgr, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileMgr_close" "', argument " "1"" of type '" "sword::FileMgr *""'"); 
  }
  arg1 = reinterpret_cast< sword::FileMgr * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_sword__FileDesc, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileMgr_close" "', argument " "2"" of type '" "sword::FileDesc *""'"); 
  }
  arg2 = reinterpret_cast< sword::FileDesc * >(argp2);
  {
    try {
      (arg1)->close(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FileMgr_flush(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::FileMgr *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__FileMgr, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileMgr_flush" "', argument " "1"" of type '" "sword::FileMgr *""'"); 
  }
  arg1 = reinterpret_cast< sword::FileMgr * >(argp1);
  {
    try {
      (arg1)->flush(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FileMgr_resourceConsumption(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::FileMgr *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  long result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__FileMgr, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileMgr_resourceConsumption" "', argument " "1"" of type '" "sword::FileMgr *""'"); 
  }
  arg1 = reinterpret_cast< sword::FileMgr * >(argp1);
  {
    try {
      result = (long)(arg1)->resourceConsumption(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_long(static_cast< long >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FileMgr_getEnvValue(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  PyObject *swig_obj[1] ;
  sword::SWBuf result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileMgr_getEnvValue" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  {
    try {
      result = sword::FileMgr::getEnvValue((char const *)arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj((new sword::SWBuf(result)), SWIGTYPE_p_sword__SWBuf, SWIG_POINTER_OWN |  0 );
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_FileMgr_hasAccess(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  int arg2 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "FileMgr_hasAccess", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileMgr_hasAccess" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileMgr_hasAccess" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    try {
      result = (bool)sword::FileMgr::hasAccess((char const *)arg1,arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_FileMgr_existsFile__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  char *arg2 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  signed char result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileMgr_existsFile" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileMgr_existsFile" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    try {
      result = (signed char)sword::FileMgr::existsFile((char const *)arg1,(char const *)arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_signed_SS_char(static_cast< signed char >(result));
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_FileMgr_existsFile__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  signed char result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileMgr_existsFile" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  {
    try {
      result = (signed char)sword::FileMgr::existsFile((char const *)arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_signed_SS_char(static_cast< signed char >(result));
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_FileMgr_existsFile(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "FileMgr_existsFile", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_FileMgr_existsFile__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_FileMgr_existsFile__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'FileMgr_existsFile'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    sword::FileMgr::existsFile(char const *,char const *)\n"
    "    sword::FileMgr::existsFile(char const *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_FileMgr_existsDir__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  char *arg2 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  signed char result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileMgr_existsDir" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileMgr_existsDir" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    try {
      result = (signed char)sword::FileMgr::existsDir((char const *)arg1,(char const *)arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_signed_SS_char(static_cast< signed char >(result));
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_FileMgr_existsDir__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  signed char result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileMgr_existsDir" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  {
    try {
      result = (signed char)sword::FileMgr::existsDir((char const *)arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_signed_SS_char(static_cast< signed char >(result));
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_FileMgr_existsDir(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "FileMgr_existsDir", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_FileMgr_existsDir__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_FileMgr_existsDir__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'FileMgr_existsDir'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    sword::FileMgr::existsDir(char const *,char const *)\n"
    "    sword::FileMgr::existsDir(char const *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_FileMgr_getDirList__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  bool arg2 ;
  bool arg3 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  std::vector< sword::DirEntry,std::allocator< sword::DirEntry > > result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileMgr_getDirList" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileMgr_getDirList" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileMgr_getDirList" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    try {
      result = sword::FileMgr::getDirList((char const *)arg1,arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = swig::from(static_cast< std::vector< sword::DirEntry,std::allocator< sword::DirEntry > > >(result));
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_FileMgr_getDirList__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  bool arg2 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  std::vector< sword::DirEntry,std::allocator< sword::DirEntry > > result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileMgr_getDirList" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileMgr_getDirList" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    try {
      result = sword::FileMgr::getDirList((char const *)arg1,arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = swig::from(static_cast< std::vector< sword::DirEntry,std::allocator< sword::DirEntry > > >(result));
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_FileMgr_getDirList__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  std::vector< sword::DirEntry,std::allocator< sword::DirEntry > > result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileMgr_getDirList" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  {
    try {
      result = sword::FileMgr::getDirList((char const *)arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = swig::from(static_cast< std::vector< sword::DirEntry,std::allocator< sword::DirEntry > > >(result));
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_FileMgr_getDirList(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "FileMgr_getDirList", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_FileMgr_getDirList__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_FileMgr_getDirList__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_FileMgr_getDirList__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'FileMgr_getDirList'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    sword::FileMgr::getDirList(char const *,bool,bool)\n"
    "    sword::FileMgr::getDirList(char const *,bool)\n"
    "    sword::FileMgr::getDirList(char const *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_FileMgr_trunc(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::FileMgr *arg1 = 0 ;
  sword::FileDesc *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  signed char result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "FileMgr_trunc", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__FileMgr, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileMgr_trunc" "', argument " "1"" of type '" "sword::FileMgr *""'"); 
  }
  arg1 = reinterpret_cast< sword::FileMgr * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_sword__FileDesc, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileMgr_trunc" "', argument " "2"" of type '" "sword::FileDesc *""'"); 
  }
  arg2 = reinterpret_cast< sword::FileDesc * >(argp2);
  {
    try {
      result = (signed char)(arg1)->trunc(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_signed_SS_char(static_cast< signed char >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FileMgr_isDirectory(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  PyObject *swig_obj[1] ;
  char result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileMgr_isDirectory" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  {
    try {
      result = (char)sword::FileMgr::isDirectory((char const *)arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_char(static_cast< char >(result));
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_FileMgr_getFileSize(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  PyObject *swig_obj[1] ;
  long result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileMgr_getFileSize" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  {
    try {
      result = (long)sword::FileMgr::getFileSize((char const *)arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_long(static_cast< long >(result));
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_FileMgr_createParent(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileMgr_createParent" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  {
    try {
      result = (int)sword::FileMgr::createParent((char const *)arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_FileMgr_createPathAndFile(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileMgr_createPathAndFile" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  {
    try {
      result = (int)sword::FileMgr::createPathAndFile((char const *)arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_FileMgr_openFile(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  int arg2 ;
  int arg3 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "FileMgr_openFile", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileMgr_openFile" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileMgr_openFile" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileMgr_openFile" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  {
    try {
      result = (int)sword::FileMgr::openFile((char const *)arg1,arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_FileMgr_openFileReadOnly(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileMgr_openFileReadOnly" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  {
    try {
      result = (int)sword::FileMgr::openFileReadOnly((char const *)arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_FileMgr_closeFile(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "FileMgr_closeFile" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  {
    try {
      sword::FileMgr::closeFile(arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FileMgr_write(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  void *arg2 = 0 ;
  long arg3 ;
  int val1 ;
  int ecode1 = 0 ;
  int res2 ;
  long val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  long result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "FileMgr_write", 3, 3, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "FileMgr_write" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1],SWIG_as_voidptrptr(&arg2), 0, 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileMgr_write" "', argument " "2"" of type '" "void const *""'"); 
  }
  ecode3 = SWIG_AsVal_long(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileMgr_write" "', argument " "3"" of type '" "long""'");
  } 
  arg3 = static_cast< long >(val3);
  {
    try {
      result = (long)sword::FileMgr::write(arg1,(void const *)arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_long(static_cast< long >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FileMgr_copyFile(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  char *arg2 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "FileMgr_copyFile", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileMgr_copyFile" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileMgr_copyFile" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    try {
      result = (int)sword::FileMgr::copyFile((char const *)arg1,(char const *)arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_FileMgr_copyDir(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  char *arg2 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "FileMgr_copyDir", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileMgr_copyDir" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileMgr_copyDir" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    try {
      result = (int)sword::FileMgr::copyDir((char const *)arg1,(char const *)arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_FileMgr_removeDir(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileMgr_removeDir" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  {
    try {
      result = (int)sword::FileMgr::removeDir((char const *)arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_FileMgr_removeFile(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileMgr_removeFile" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  {
    try {
      result = (int)sword::FileMgr::removeFile((char const *)arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_FileMgr_getLine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::FileDesc *arg1 = 0 ;
  sword::SWBuf *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  char result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "FileMgr_getLine", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__FileDesc, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileMgr_getLine" "', argument " "1"" of type '" "sword::FileDesc *""'"); 
  }
  arg1 = reinterpret_cast< sword::FileDesc * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_sword__SWBuf,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileMgr_getLine" "', argument " "2"" of type '" "sword::SWBuf &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "FileMgr_getLine" "', argument " "2"" of type '" "sword::SWBuf &""'"); 
  }
  arg2 = reinterpret_cast< sword::SWBuf * >(argp2);
  {
    try {
      result = (char)sword::FileMgr::getLine(arg1,*arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_char(static_cast< char >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FileMgr_getHomeDir(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::FileMgr *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  sword::SWBuf result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__FileMgr, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileMgr_getHomeDir" "', argument " "1"" of type '" "sword::FileMgr *""'"); 
  }
  arg1 = reinterpret_cast< sword::FileMgr * >(argp1);
  {
    try {
      result = (arg1)->getHomeDir(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj((new sword::SWBuf(result)), SWIGTYPE_p_sword__SWBuf, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *FileMgr_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_sword__FileMgr, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *FileMgr_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_FileDesc_getFd(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::FileDesc *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__FileDesc, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDesc_getFd" "', argument " "1"" of type '" "sword::FileDesc *""'"); 
  }
  arg1 = reinterpret_cast< sword::FileDesc * >(argp1);
  {
    try {
      result = (int)(arg1)->getFd(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FileDesc_seek(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::FileDesc *arg1 = 0 ;
  long arg2 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  long val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  long result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "FileDesc_seek", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__FileDesc, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDesc_seek" "', argument " "1"" of type '" "sword::FileDesc *""'"); 
  }
  arg1 = reinterpret_cast< sword::FileDesc * >(argp1);
  ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDesc_seek" "', argument " "2"" of type '" "long""'");
  } 
  arg2 = static_cast< long >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDesc_seek" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  {
    try {
      result = (long)(arg1)->seek(arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_long(static_cast< long >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FileDesc_read(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::FileDesc *arg1 = 0 ;
  void *arg2 = 0 ;
  long arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  long val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  long result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "FileDesc_read", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__FileDesc, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDesc_read" "', argument " "1"" of type '" "sword::FileDesc *""'"); 
  }
  arg1 = reinterpret_cast< sword::FileDesc * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1],SWIG_as_voidptrptr(&arg2), 0, 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileDesc_read" "', argument " "2"" of type '" "void *""'"); 
  }
  ecode3 = SWIG_AsVal_long(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDesc_read" "', argument " "3"" of type '" "long""'");
  } 
  arg3 = static_cast< long >(val3);
  {
    try {
      result = (long)(arg1)->read(arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_long(static_cast< long >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FileDesc_write(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::FileDesc *arg1 = 0 ;
  void *arg2 = 0 ;
  long arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  long val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  long result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "FileDesc_write", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__FileDesc, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDesc_write" "', argument " "1"" of type '" "sword::FileDesc *""'"); 
  }
  arg1 = reinterpret_cast< sword::FileDesc * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1],SWIG_as_voidptrptr(&arg2), 0, 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileDesc_write" "', argument " "2"" of type '" "void const *""'"); 
  }
  ecode3 = SWIG_AsVal_long(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDesc_write" "', argument " "3"" of type '" "long""'");
  } 
  arg3 = static_cast< long >(val3);
  {
    try {
      result = (long)(arg1)->write((void const *)arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_long(static_cast< long >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FileDesc_path_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::FileDesc *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "FileDesc_path_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__FileDesc, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDesc_path_set" "', argument " "1"" of type '" "sword::FileDesc *""'"); 
  }
  arg1 = reinterpret_cast< sword::FileDesc * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileDesc_path_set" "', argument " "2"" of type '" "char *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  delete[] arg1->path;
  if (arg2) {
    size_t size = strlen(reinterpret_cast< const char * >(arg2)) + 1;
    arg1->path = (char *)reinterpret_cast< char* >(memcpy(new char[size], reinterpret_cast< const char * >(arg2), sizeof(char)*(size)));
  } else {
    arg1->path = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_FileDesc_path_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::FileDesc *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__FileDesc, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDesc_path_get" "', argument " "1"" of type '" "sword::FileDesc *""'"); 
  }
  arg1 = reinterpret_cast< sword::FileDesc * >(argp1);
  result = (char *) ((arg1)->path);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FileDesc_mode_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::FileDesc *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "FileDesc_mode_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__FileDesc, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDesc_mode_set" "', argument " "1"" of type '" "sword::FileDesc *""'"); 
  }
  arg1 = reinterpret_cast< sword::FileDesc * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDesc_mode_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  if (arg1) (arg1)->mode = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FileDesc_mode_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::FileDesc *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__FileDesc, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDesc_mode_get" "', argument " "1"" of type '" "sword::FileDesc *""'"); 
  }
  arg1 = reinterpret_cast< sword::FileDesc * >(argp1);
  result = (int) ((arg1)->mode);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FileDesc_perms_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::FileDesc *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "FileDesc_perms_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__FileDesc, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDesc_perms_set" "', argument " "1"" of type '" "sword::FileDesc *""'"); 
  }
  arg1 = reinterpret_cast< sword::FileDesc * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDesc_perms_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  if (arg1) (arg1)->perms = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FileDesc_perms_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::FileDesc *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__FileDesc, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDesc_perms_get" "', argument " "1"" of type '" "sword::FileDesc *""'"); 
  }
  arg1 = reinterpret_cast< sword::FileDesc * >(argp1);
  result = (int) ((arg1)->perms);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FileDesc_tryDowngrade_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::FileDesc *arg1 = 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "FileDesc_tryDowngrade_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__FileDesc, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDesc_tryDowngrade_set" "', argument " "1"" of type '" "sword::FileDesc *""'"); 
  }
  arg1 = reinterpret_cast< sword::FileDesc * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDesc_tryDowngrade_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->tryDowngrade = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FileDesc_tryDowngrade_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::FileDesc *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__FileDesc, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDesc_tryDowngrade_get" "', argument " "1"" of type '" "sword::FileDesc *""'"); 
  }
  arg1 = reinterpret_cast< sword::FileDesc * >(argp1);
  result = (bool) ((arg1)->tryDowngrade);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *FileDesc_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_sword__FileDesc, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_EncodingFilterMgr__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char arg1 ;
  char val1 ;
  int ecode1 = 0 ;
  sword::EncodingFilterMgr *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_char(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EncodingFilterMgr" "', argument " "1"" of type '" "char""'");
  } 
  arg1 = static_cast< char >(val1);
  {
    try {
      result = (sword::EncodingFilterMgr *)new sword::EncodingFilterMgr(arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__EncodingFilterMgr, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EncodingFilterMgr__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  sword::EncodingFilterMgr *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (sword::EncodingFilterMgr *)new sword::EncodingFilterMgr(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__EncodingFilterMgr, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EncodingFilterMgr(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_EncodingFilterMgr", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_EncodingFilterMgr__SWIG_1(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_AsVal_char(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_EncodingFilterMgr__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_EncodingFilterMgr'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    sword::EncodingFilterMgr::EncodingFilterMgr(char)\n"
    "    sword::EncodingFilterMgr::EncodingFilterMgr()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_EncodingFilterMgr(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::EncodingFilterMgr *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__EncodingFilterMgr, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EncodingFilterMgr" "', argument " "1"" of type '" "sword::EncodingFilterMgr *""'"); 
  }
  arg1 = reinterpret_cast< sword::EncodingFilterMgr * >(argp1);
  {
    try {
      delete arg1; 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_EncodingFilterMgr_Encoding(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::EncodingFilterMgr *arg1 = 0 ;
  char arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  char result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "EncodingFilterMgr_Encoding", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__EncodingFilterMgr, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EncodingFilterMgr_Encoding" "', argument " "1"" of type '" "sword::EncodingFilterMgr *""'"); 
  }
  arg1 = reinterpret_cast< sword::EncodingFilterMgr * >(argp1);
  ecode2 = SWIG_AsVal_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EncodingFilterMgr_Encoding" "', argument " "2"" of type '" "char""'");
  } 
  arg2 = static_cast< char >(val2);
  {
    try {
      result = (char)(arg1)->Encoding(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_char(static_cast< char >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_EncodingFilterMgr_getEncoding(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::EncodingFilterMgr *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__EncodingFilterMgr, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EncodingFilterMgr_getEncoding" "', argument " "1"" of type '" "sword::EncodingFilterMgr const *""'"); 
  }
  arg1 = reinterpret_cast< sword::EncodingFilterMgr * >(argp1);
  {
    try {
      result = (char)((sword::EncodingFilterMgr const *)arg1)->getEncoding(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_char(static_cast< char >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_EncodingFilterMgr_setEncoding(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::EncodingFilterMgr *arg1 = 0 ;
  char arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "EncodingFilterMgr_setEncoding", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__EncodingFilterMgr, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EncodingFilterMgr_setEncoding" "', argument " "1"" of type '" "sword::EncodingFilterMgr *""'"); 
  }
  arg1 = reinterpret_cast< sword::EncodingFilterMgr * >(argp1);
  ecode2 = SWIG_AsVal_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EncodingFilterMgr_setEncoding" "', argument " "2"" of type '" "char""'");
  } 
  arg2 = static_cast< char >(val2);
  {
    try {
      (arg1)->setEncoding(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_EncodingFilterMgr_addRawFilters(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::EncodingFilterMgr *arg1 = 0 ;
  sword::SWModule *arg2 = 0 ;
  sword::ConfigEntMap *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "EncodingFilterMgr_addRawFilters", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__EncodingFilterMgr, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EncodingFilterMgr_addRawFilters" "', argument " "1"" of type '" "sword::EncodingFilterMgr *""'"); 
  }
  arg1 = reinterpret_cast< sword::EncodingFilterMgr * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_sword__SWModule, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EncodingFilterMgr_addRawFilters" "', argument " "2"" of type '" "sword::SWModule *""'"); 
  }
  arg2 = reinterpret_cast< sword::SWModule * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_sword__multimapwithdefaultT_sword__SWBuf_sword__SWBuf_std__lessT_sword__SWBuf_t_t,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "EncodingFilterMgr_addRawFilters" "', argument " "3"" of type '" "sword::ConfigEntMap &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "EncodingFilterMgr_addRawFilters" "', argument " "3"" of type '" "sword::ConfigEntMap &""'"); 
  }
  arg3 = reinterpret_cast< sword::ConfigEntMap * >(argp3);
  {
    try {
      (arg1)->addRawFilters(arg2,*arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_EncodingFilterMgr_addEncodingFilters(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::EncodingFilterMgr *arg1 = 0 ;
  sword::SWModule *arg2 = 0 ;
  sword::ConfigEntMap *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "EncodingFilterMgr_addEncodingFilters", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__EncodingFilterMgr, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EncodingFilterMgr_addEncodingFilters" "', argument " "1"" of type '" "sword::EncodingFilterMgr *""'"); 
  }
  arg1 = reinterpret_cast< sword::EncodingFilterMgr * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_sword__SWModule, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EncodingFilterMgr_addEncodingFilters" "', argument " "2"" of type '" "sword::SWModule *""'"); 
  }
  arg2 = reinterpret_cast< sword::SWModule * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_sword__multimapwithdefaultT_sword__SWBuf_sword__SWBuf_std__lessT_sword__SWBuf_t_t,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "EncodingFilterMgr_addEncodingFilters" "', argument " "3"" of type '" "sword::ConfigEntMap &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "EncodingFilterMgr_addEncodingFilters" "', argument " "3"" of type '" "sword::ConfigEntMap &""'"); 
  }
  arg3 = reinterpret_cast< sword::ConfigEntMap * >(argp3);
  {
    try {
      (arg1)->addEncodingFilters(arg2,*arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_EncodingFilterMgr_castTo(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWFilterMgr *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  sword::EncodingFilterMgr *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWFilterMgr, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EncodingFilterMgr_castTo" "', argument " "1"" of type '" "sword::SWFilterMgr *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWFilterMgr * >(argp1);
  {
    try {
      result = (sword::EncodingFilterMgr *)sword_EncodingFilterMgr_castTo(arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__EncodingFilterMgr, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *EncodingFilterMgr_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_sword__EncodingFilterMgr, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *EncodingFilterMgr_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_MarkupFilterMgr__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char arg1 ;
  char arg2 ;
  char val1 ;
  int ecode1 = 0 ;
  char val2 ;
  int ecode2 = 0 ;
  sword::MarkupFilterMgr *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_char(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MarkupFilterMgr" "', argument " "1"" of type '" "char""'");
  } 
  arg1 = static_cast< char >(val1);
  ecode2 = SWIG_AsVal_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MarkupFilterMgr" "', argument " "2"" of type '" "char""'");
  } 
  arg2 = static_cast< char >(val2);
  {
    try {
      result = (sword::MarkupFilterMgr *)new sword::MarkupFilterMgr(arg1,arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__MarkupFilterMgr, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MarkupFilterMgr__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char arg1 ;
  char val1 ;
  int ecode1 = 0 ;
  sword::MarkupFilterMgr *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_char(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MarkupFilterMgr" "', argument " "1"" of type '" "char""'");
  } 
  arg1 = static_cast< char >(val1);
  {
    try {
      result = (sword::MarkupFilterMgr *)new sword::MarkupFilterMgr(arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__MarkupFilterMgr, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MarkupFilterMgr__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  sword::MarkupFilterMgr *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (sword::MarkupFilterMgr *)new sword::MarkupFilterMgr(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__MarkupFilterMgr, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MarkupFilterMgr(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_MarkupFilterMgr", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_MarkupFilterMgr__SWIG_2(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_AsVal_char(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_MarkupFilterMgr__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_AsVal_char(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_char(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_MarkupFilterMgr__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_MarkupFilterMgr'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    sword::MarkupFilterMgr::MarkupFilterMgr(char,char)\n"
    "    sword::MarkupFilterMgr::MarkupFilterMgr(char)\n"
    "    sword::MarkupFilterMgr::MarkupFilterMgr()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_MarkupFilterMgr(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::MarkupFilterMgr *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__MarkupFilterMgr, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MarkupFilterMgr" "', argument " "1"" of type '" "sword::MarkupFilterMgr *""'"); 
  }
  arg1 = reinterpret_cast< sword::MarkupFilterMgr * >(argp1);
  {
    try {
      delete arg1; 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MarkupFilterMgr_Markup__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::MarkupFilterMgr *arg1 = 0 ;
  char arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char val2 ;
  int ecode2 = 0 ;
  char result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__MarkupFilterMgr, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkupFilterMgr_Markup" "', argument " "1"" of type '" "sword::MarkupFilterMgr *""'"); 
  }
  arg1 = reinterpret_cast< sword::MarkupFilterMgr * >(argp1);
  ecode2 = SWIG_AsVal_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MarkupFilterMgr_Markup" "', argument " "2"" of type '" "char""'");
  } 
  arg2 = static_cast< char >(val2);
  {
    try {
      result = (char)(arg1)->Markup(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_char(static_cast< char >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MarkupFilterMgr_Markup__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::MarkupFilterMgr *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__MarkupFilterMgr, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkupFilterMgr_Markup" "', argument " "1"" of type '" "sword::MarkupFilterMgr *""'"); 
  }
  arg1 = reinterpret_cast< sword::MarkupFilterMgr * >(argp1);
  {
    try {
      result = (char)(arg1)->Markup(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_char(static_cast< char >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MarkupFilterMgr_Markup(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "MarkupFilterMgr_Markup", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__MarkupFilterMgr, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_MarkupFilterMgr_Markup__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__MarkupFilterMgr, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_char(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_MarkupFilterMgr_Markup__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'MarkupFilterMgr_Markup'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    sword::MarkupFilterMgr::Markup(char)\n"
    "    sword::MarkupFilterMgr::Markup()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_MarkupFilterMgr_getMarkup(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::MarkupFilterMgr *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__MarkupFilterMgr, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkupFilterMgr_getMarkup" "', argument " "1"" of type '" "sword::MarkupFilterMgr const *""'"); 
  }
  arg1 = reinterpret_cast< sword::MarkupFilterMgr * >(argp1);
  {
    try {
      result = (char)((sword::MarkupFilterMgr const *)arg1)->getMarkup(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_char(static_cast< char >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MarkupFilterMgr_setMarkup(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::MarkupFilterMgr *arg1 = 0 ;
  char arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "MarkupFilterMgr_setMarkup", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__MarkupFilterMgr, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkupFilterMgr_setMarkup" "', argument " "1"" of type '" "sword::MarkupFilterMgr *""'"); 
  }
  arg1 = reinterpret_cast< sword::MarkupFilterMgr * >(argp1);
  ecode2 = SWIG_AsVal_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MarkupFilterMgr_setMarkup" "', argument " "2"" of type '" "char""'");
  } 
  arg2 = static_cast< char >(val2);
  {
    try {
      (arg1)->setMarkup(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MarkupFilterMgr_addRenderFilters(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::MarkupFilterMgr *arg1 = 0 ;
  sword::SWModule *arg2 = 0 ;
  sword::ConfigEntMap *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "MarkupFilterMgr_addRenderFilters", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__MarkupFilterMgr, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkupFilterMgr_addRenderFilters" "', argument " "1"" of type '" "sword::MarkupFilterMgr *""'"); 
  }
  arg1 = reinterpret_cast< sword::MarkupFilterMgr * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_sword__SWModule, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MarkupFilterMgr_addRenderFilters" "', argument " "2"" of type '" "sword::SWModule *""'"); 
  }
  arg2 = reinterpret_cast< sword::SWModule * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_sword__multimapwithdefaultT_sword__SWBuf_sword__SWBuf_std__lessT_sword__SWBuf_t_t,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MarkupFilterMgr_addRenderFilters" "', argument " "3"" of type '" "sword::ConfigEntMap &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "MarkupFilterMgr_addRenderFilters" "', argument " "3"" of type '" "sword::ConfigEntMap &""'"); 
  }
  arg3 = reinterpret_cast< sword::ConfigEntMap * >(argp3);
  {
    try {
      (arg1)->addRenderFilters(arg2,*arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MarkupFilterMgr_castTo(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWFilterMgr *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  sword::MarkupFilterMgr *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWFilterMgr, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkupFilterMgr_castTo" "', argument " "1"" of type '" "sword::SWFilterMgr *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWFilterMgr * >(argp1);
  {
    try {
      result = (sword::MarkupFilterMgr *)sword_MarkupFilterMgr_castTo(arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__MarkupFilterMgr, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *MarkupFilterMgr_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_sword__MarkupFilterMgr, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *MarkupFilterMgr_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN int Swig_var_ENDOFABBREVS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ENDOFABBREVS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ENDOFABBREVS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(sword::ENDOFABBREVS));
  return pyobj;
}


SWIGINTERN PyObject *_wrap_new_SWLocale(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  PyObject *swig_obj[1] ;
  sword::SWLocale *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SWLocale" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  {
    try {
      result = (sword::SWLocale *)new sword::SWLocale((char const *)arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__SWLocale, SWIG_POINTER_NEW |  0 );
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SWLocale(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWLocale *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWLocale, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SWLocale" "', argument " "1"" of type '" "sword::SWLocale *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWLocale * >(argp1);
  {
    try {
      delete arg1; 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWLocale_getName(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWLocale *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWLocale, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWLocale_getName" "', argument " "1"" of type '" "sword::SWLocale *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWLocale * >(argp1);
  {
    try {
      result = (char *)(arg1)->getName(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWLocale_getDescription(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWLocale *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWLocale, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWLocale_getDescription" "', argument " "1"" of type '" "sword::SWLocale *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWLocale * >(argp1);
  {
    try {
      result = (char *)(arg1)->getDescription(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWLocale_getEncoding(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWLocale *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWLocale, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWLocale_getEncoding" "', argument " "1"" of type '" "sword::SWLocale *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWLocale * >(argp1);
  {
    try {
      result = (char *)(arg1)->getEncoding(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWLocale_translate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWLocale *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  char *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SWLocale_translate", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWLocale, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWLocale_translate" "', argument " "1"" of type '" "sword::SWLocale *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWLocale * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SWLocale_translate" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    try {
      result = (char *)(arg1)->translate((char const *)arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWLocale_augment(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWLocale *arg1 = 0 ;
  sword::SWLocale *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SWLocale_augment", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWLocale, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWLocale_augment" "', argument " "1"" of type '" "sword::SWLocale *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWLocale * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_sword__SWLocale,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SWLocale_augment" "', argument " "2"" of type '" "sword::SWLocale &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SWLocale_augment" "', argument " "2"" of type '" "sword::SWLocale &""'"); 
  }
  arg2 = reinterpret_cast< sword::SWLocale * >(argp2);
  {
    try {
      (arg1)->augment(*arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN int Swig_var_SWLocale_DEFAULT_LOCALE_NAME_set(PyObject *_val) {
  {
    char *cptr = 0; size_t csize = 0; int alloc = SWIG_NEWOBJ;
    int res = SWIG_AsCharPtrAndSize(_val, &cptr, &csize, &alloc);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in variable '""sword::SWLocale::DEFAULT_LOCALE_NAME""' of type '""char const *""'");
    }
    if (alloc == SWIG_NEWOBJ) {
      sword::SWLocale::DEFAULT_LOCALE_NAME = cptr;
    } else {
      sword::SWLocale::DEFAULT_LOCALE_NAME = csize ? (char const *)reinterpret_cast< char* >(memcpy(new char[csize], cptr, sizeof(char)*(csize))) : 0;
    }
  }
  return 0;
fail:
  return 1;
}


SWIGINTERN PyObject *Swig_var_SWLocale_DEFAULT_LOCALE_NAME_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(sword::SWLocale::DEFAULT_LOCALE_NAME);
  return pyobj;
}


SWIGINTERN PyObject *_wrap_SWLocale_DEFAULT_LOCALE_NAME_get(PyObject *SWIGUNUSEDPARM(self), PyObject *SWIGUNUSEDPARM(args)) {
  return Swig_var_SWLocale_DEFAULT_LOCALE_NAME_get();
}


SWIGINTERN PyObject *_wrap_SWLocale_DEFAULT_LOCALE_NAME_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  int res;
  
  res = Swig_var_SWLocale_DEFAULT_LOCALE_NAME_set(args);
  return !res ? SWIG_Py_Void() : NULL;
}


SWIGINTERN PyObject *_wrap_SWLocale_getBookAbbrevs(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWLocale *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  sword::abbrev *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWLocale, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWLocale_getBookAbbrevs" "', argument " "1"" of type '" "sword::SWLocale *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWLocale * >(argp1);
  {
    try {
      result = (sword::abbrev *)sword_SWLocale_getBookAbbrevs(arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__abbrev, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SWLocale_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_sword__SWLocale, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SWLocale_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SWCompress(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWCompress *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SWCompress", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (sword::SWCompress *)new sword::SWCompress(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__SWCompress, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SWCompress(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWCompress *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWCompress, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SWCompress" "', argument " "1"" of type '" "sword::SWCompress *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWCompress * >(argp1);
  {
    try {
      delete arg1; 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWCompress_setUncompressedBuf__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::SWCompress *arg1 = 0 ;
  char *arg2 = 0 ;
  unsigned long *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWCompress, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWCompress_setUncompressedBuf" "', argument " "1"" of type '" "sword::SWCompress *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWCompress * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SWCompress_setUncompressedBuf" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_unsigned_long, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SWCompress_setUncompressedBuf" "', argument " "3"" of type '" "unsigned long *""'"); 
  }
  arg3 = reinterpret_cast< unsigned long * >(argp3);
  {
    try {
      (arg1)->setUncompressedBuf((char const *)arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWCompress_setUncompressedBuf__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::SWCompress *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWCompress, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWCompress_setUncompressedBuf" "', argument " "1"" of type '" "sword::SWCompress *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWCompress * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SWCompress_setUncompressedBuf" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    try {
      (arg1)->setUncompressedBuf((char const *)arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWCompress_setUncompressedBuf__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::SWCompress *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWCompress, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWCompress_setUncompressedBuf" "', argument " "1"" of type '" "sword::SWCompress *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWCompress * >(argp1);
  {
    try {
      (arg1)->setUncompressedBuf(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWCompress_setUncompressedBuf(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SWCompress_setUncompressedBuf", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__SWCompress, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SWCompress_setUncompressedBuf__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__SWCompress, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SWCompress_setUncompressedBuf__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__SWCompress, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_unsigned_long, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SWCompress_setUncompressedBuf__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SWCompress_setUncompressedBuf'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    sword::SWCompress::setUncompressedBuf(char const *,unsigned long *)\n"
    "    sword::SWCompress::setUncompressedBuf(char const *)\n"
    "    sword::SWCompress::setUncompressedBuf()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SWCompress_getUncompressedBuf__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::SWCompress *arg1 = 0 ;
  unsigned long *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  char *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWCompress, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWCompress_getUncompressedBuf" "', argument " "1"" of type '" "sword::SWCompress *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWCompress * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_unsigned_long, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SWCompress_getUncompressedBuf" "', argument " "2"" of type '" "unsigned long *""'"); 
  }
  arg2 = reinterpret_cast< unsigned long * >(argp2);
  {
    try {
      result = (char *)(arg1)->getUncompressedBuf(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWCompress_getUncompressedBuf__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::SWCompress *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWCompress, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWCompress_getUncompressedBuf" "', argument " "1"" of type '" "sword::SWCompress *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWCompress * >(argp1);
  {
    try {
      result = (char *)(arg1)->getUncompressedBuf(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWCompress_getUncompressedBuf(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SWCompress_getUncompressedBuf", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__SWCompress, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SWCompress_getUncompressedBuf__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__SWCompress, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_unsigned_long, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SWCompress_getUncompressedBuf__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SWCompress_getUncompressedBuf'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    sword::SWCompress::getUncompressedBuf(unsigned long *)\n"
    "    sword::SWCompress::getUncompressedBuf()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SWCompress_setCompressedBuf__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::SWCompress *arg1 = 0 ;
  unsigned long *arg2 = 0 ;
  char *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWCompress, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWCompress_setCompressedBuf" "', argument " "1"" of type '" "sword::SWCompress *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWCompress * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_unsigned_long, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SWCompress_setCompressedBuf" "', argument " "2"" of type '" "unsigned long *""'"); 
  }
  arg2 = reinterpret_cast< unsigned long * >(argp2);
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SWCompress_setCompressedBuf" "', argument " "3"" of type '" "char *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  {
    try {
      (arg1)->setCompressedBuf(arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return resultobj;
fail:
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWCompress_setCompressedBuf__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::SWCompress *arg1 = 0 ;
  unsigned long *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWCompress, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWCompress_setCompressedBuf" "', argument " "1"" of type '" "sword::SWCompress *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWCompress * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_unsigned_long, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SWCompress_setCompressedBuf" "', argument " "2"" of type '" "unsigned long *""'"); 
  }
  arg2 = reinterpret_cast< unsigned long * >(argp2);
  {
    try {
      (arg1)->setCompressedBuf(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWCompress_setCompressedBuf(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SWCompress_setCompressedBuf", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__SWCompress, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_unsigned_long, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SWCompress_setCompressedBuf__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__SWCompress, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_unsigned_long, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SWCompress_setCompressedBuf__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SWCompress_setCompressedBuf'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    sword::SWCompress::setCompressedBuf(unsigned long *,char *)\n"
    "    sword::SWCompress::setCompressedBuf(unsigned long *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SWCompress_getCompressedBuf__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::SWCompress *arg1 = 0 ;
  unsigned long *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  char *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWCompress, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWCompress_getCompressedBuf" "', argument " "1"" of type '" "sword::SWCompress *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWCompress * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_unsigned_long, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SWCompress_getCompressedBuf" "', argument " "2"" of type '" "unsigned long *""'"); 
  }
  arg2 = reinterpret_cast< unsigned long * >(argp2);
  {
    try {
      result = (char *)(arg1)->getCompressedBuf(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWCompress_getCompressedBuf__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::SWCompress *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWCompress, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWCompress_getCompressedBuf" "', argument " "1"" of type '" "sword::SWCompress *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWCompress * >(argp1);
  {
    try {
      result = (char *)(arg1)->getCompressedBuf(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWCompress_getCompressedBuf(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SWCompress_getCompressedBuf", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__SWCompress, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SWCompress_getCompressedBuf__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__SWCompress, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_unsigned_long, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SWCompress_getCompressedBuf__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SWCompress_getCompressedBuf'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    sword::SWCompress::getCompressedBuf(unsigned long *)\n"
    "    sword::SWCompress::getCompressedBuf()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SWCompress_getChars(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWCompress *arg1 = 0 ;
  char *arg2 = 0 ;
  unsigned long arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  unsigned long val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  unsigned long result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SWCompress_getChars", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWCompress, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWCompress_getChars" "', argument " "1"" of type '" "sword::SWCompress *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWCompress * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SWCompress_getChars" "', argument " "2"" of type '" "char *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  ecode3 = SWIG_AsVal_unsigned_SS_long(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SWCompress_getChars" "', argument " "3"" of type '" "unsigned long""'");
  } 
  arg3 = static_cast< unsigned long >(val3);
  {
    try {
      result = (unsigned long)(arg1)->getChars(arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWCompress_sendChars(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWCompress *arg1 = 0 ;
  char *arg2 = 0 ;
  unsigned long arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  unsigned long val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  unsigned long result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SWCompress_sendChars", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWCompress, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWCompress_sendChars" "', argument " "1"" of type '" "sword::SWCompress *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWCompress * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SWCompress_sendChars" "', argument " "2"" of type '" "char *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  ecode3 = SWIG_AsVal_unsigned_SS_long(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SWCompress_sendChars" "', argument " "3"" of type '" "unsigned long""'");
  } 
  arg3 = static_cast< unsigned long >(val3);
  {
    try {
      result = (unsigned long)(arg1)->sendChars(arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWCompress_encode(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWCompress *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWCompress, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWCompress_encode" "', argument " "1"" of type '" "sword::SWCompress *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWCompress * >(argp1);
  {
    try {
      (arg1)->encode(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWCompress_decode(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWCompress *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWCompress, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWCompress_decode" "', argument " "1"" of type '" "sword::SWCompress *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWCompress * >(argp1);
  {
    try {
      (arg1)->decode(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWCompress_setLevel(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWCompress *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SWCompress_setLevel", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWCompress, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWCompress_setLevel" "', argument " "1"" of type '" "sword::SWCompress *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWCompress * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SWCompress_setLevel" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    try {
      (arg1)->setLevel(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWCompress_getLevel(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWCompress *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWCompress, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWCompress_getLevel" "', argument " "1"" of type '" "sword::SWCompress *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWCompress * >(argp1);
  {
    try {
      result = (int)(arg1)->getLevel(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SWCompress_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_sword__SWCompress, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SWCompress_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_LZSSCompress(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::LZSSCompress *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_LZSSCompress", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (sword::LZSSCompress *)new sword::LZSSCompress(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__LZSSCompress, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_LZSSCompress(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::LZSSCompress *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__LZSSCompress, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LZSSCompress" "', argument " "1"" of type '" "sword::LZSSCompress *""'"); 
  }
  arg1 = reinterpret_cast< sword::LZSSCompress * >(argp1);
  {
    try {
      delete arg1; 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LZSSCompress_encode(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::LZSSCompress *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__LZSSCompress, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LZSSCompress_encode" "', argument " "1"" of type '" "sword::LZSSCompress *""'"); 
  }
  arg1 = reinterpret_cast< sword::LZSSCompress * >(argp1);
  {
    try {
      (arg1)->encode(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LZSSCompress_decode(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::LZSSCompress *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__LZSSCompress, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LZSSCompress_decode" "', argument " "1"" of type '" "sword::LZSSCompress *""'"); 
  }
  arg1 = reinterpret_cast< sword::LZSSCompress * >(argp1);
  {
    try {
      (arg1)->decode(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LZSSCompress_castTo(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWCompress *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  sword::LZSSCompress *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWCompress, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LZSSCompress_castTo" "', argument " "1"" of type '" "sword::SWCompress *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWCompress * >(argp1);
  {
    try {
      result = (sword::LZSSCompress *)sword_LZSSCompress_castTo(arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__LZSSCompress, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *LZSSCompress_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_sword__LZSSCompress, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *LZSSCompress_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_ZipCompress(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::ZipCompress *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_ZipCompress", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (sword::ZipCompress *)new sword::ZipCompress(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__ZipCompress, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ZipCompress(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::ZipCompress *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__ZipCompress, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ZipCompress" "', argument " "1"" of type '" "sword::ZipCompress *""'"); 
  }
  arg1 = reinterpret_cast< sword::ZipCompress * >(argp1);
  {
    try {
      delete arg1; 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ZipCompress_encode(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::ZipCompress *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__ZipCompress, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipCompress_encode" "', argument " "1"" of type '" "sword::ZipCompress *""'"); 
  }
  arg1 = reinterpret_cast< sword::ZipCompress * >(argp1);
  {
    try {
      (arg1)->encode(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ZipCompress_decode(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::ZipCompress *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__ZipCompress, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipCompress_decode" "', argument " "1"" of type '" "sword::ZipCompress *""'"); 
  }
  arg1 = reinterpret_cast< sword::ZipCompress * >(argp1);
  {
    try {
      (arg1)->decode(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ZipCompress_unTarGZ(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  char *arg2 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  char result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ZipCompress_unTarGZ", 2, 2, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ZipCompress_unTarGZ" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ZipCompress_unTarGZ" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    try {
      result = (char)sword::ZipCompress::unTarGZ(arg1,(char const *)arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_char(static_cast< char >(result));
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ZipCompress_castTo(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWCompress *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  sword::ZipCompress *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWCompress, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipCompress_castTo" "', argument " "1"" of type '" "sword::SWCompress *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWCompress * >(argp1);
  {
    try {
      result = (sword::ZipCompress *)sword_ZipCompress_castTo(arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__ZipCompress, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ZipCompress_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_sword__ZipCompress, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *ZipCompress_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_delete_SWCom(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWCom *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWCom, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SWCom" "', argument " "1"" of type '" "sword::SWCom *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWCom * >(argp1);
  {
    try {
      delete arg1; 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWCom_createKey(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWCom *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  sword::SWKey *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWCom, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWCom_createKey" "', argument " "1"" of type '" "sword::SWCom const *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWCom * >(argp1);
  {
    try {
      result = (sword::SWKey *)((sword::SWCom const *)arg1)->createKey(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__SWKey, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWCom_getIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWCom *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  long result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWCom, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWCom_getIndex" "', argument " "1"" of type '" "sword::SWCom const *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWCom * >(argp1);
  {
    try {
      result = (long)((sword::SWCom const *)arg1)->getIndex(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_long(static_cast< long >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWCom_setIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWCom *arg1 = 0 ;
  long arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  long val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SWCom_setIndex", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWCom, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWCom_setIndex" "', argument " "1"" of type '" "sword::SWCom *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWCom * >(argp1);
  ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SWCom_setIndex" "', argument " "2"" of type '" "long""'");
  } 
  arg2 = static_cast< long >(val2);
  {
    try {
      (arg1)->setIndex(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWCom___lshift____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::SWCom *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  sword::SWModule *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWCom, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWCom___lshift__" "', argument " "1"" of type '" "sword::SWCom *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWCom * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SWCom___lshift__" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    try {
      result = (sword::SWModule *) &(arg1)->operator <<((char const *)arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__SWModule, 0 |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SWCom___lshift____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::SWCom *arg1 = 0 ;
  sword::SWKey *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  sword::SWModule *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWCom, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWCom___lshift__" "', argument " "1"" of type '" "sword::SWCom *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWCom * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_sword__SWKey, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SWCom___lshift__" "', argument " "2"" of type '" "sword::SWKey const *""'"); 
  }
  arg2 = reinterpret_cast< sword::SWKey * >(argp2);
  {
    try {
      result = (sword::SWModule *) &(arg1)->operator <<((sword::SWKey const *)arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__SWModule, 0 |  0 );
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SWCom___lshift__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SWCom___lshift__", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__SWCom, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_sword__SWKey, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SWCom___lshift____SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__SWCom, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SWCom___lshift____SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SWCom___isub__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWCom *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  sword::SWModule *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SWCom___isub__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWCom, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWCom___isub__" "', argument " "1"" of type '" "sword::SWCom *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWCom * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SWCom___isub__" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    try {
      result = (sword::SWModule *) &(arg1)->operator -=(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__SWModule, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWCom___iadd__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWCom *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  sword::SWModule *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SWCom___iadd__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWCom, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWCom___iadd__" "', argument " "1"" of type '" "sword::SWCom *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWCom * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SWCom___iadd__" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    try {
      result = (sword::SWModule *) &(arg1)->operator +=(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__SWModule, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWCom_castTo(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWModule *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  sword::SWCom *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWCom_castTo" "', argument " "1"" of type '" "sword::SWModule *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWModule * >(argp1);
  {
    try {
      result = (sword::SWCom *)sword_SWCom_castTo(arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__SWCom, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SWCom_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_sword__SWCom, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_RawCom__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  char *arg2 = 0 ;
  char *arg3 = 0 ;
  sword::SWDisplay *arg4 = 0 ;
  char arg5 ;
  char arg6 ;
  char arg7 ;
  char *arg8 = 0 ;
  char *arg9 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  char val5 ;
  int ecode5 = 0 ;
  char val6 ;
  int ecode6 = 0 ;
  char val7 ;
  int ecode7 = 0 ;
  int res8 ;
  char *buf8 = 0 ;
  int alloc8 = 0 ;
  int res9 ;
  char *buf9 = 0 ;
  int alloc9 = 0 ;
  sword::RawCom *result = 0 ;
  
  (void)self;
  if ((nobjs < 9) || (nobjs > 9)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_RawCom" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_RawCom" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_RawCom" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_sword__SWDisplay, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_RawCom" "', argument " "4"" of type '" "sword::SWDisplay *""'"); 
  }
  arg4 = reinterpret_cast< sword::SWDisplay * >(argp4);
  ecode5 = SWIG_AsVal_char(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_RawCom" "', argument " "5"" of type '" "char""'");
  } 
  arg5 = static_cast< char >(val5);
  ecode6 = SWIG_AsVal_char(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_RawCom" "', argument " "6"" of type '" "char""'");
  } 
  arg6 = static_cast< char >(val6);
  ecode7 = SWIG_AsVal_char(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_RawCom" "', argument " "7"" of type '" "char""'");
  } 
  arg7 = static_cast< char >(val7);
  res8 = SWIG_AsCharPtrAndSize(swig_obj[7], &buf8, NULL, &alloc8);
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "new_RawCom" "', argument " "8"" of type '" "char const *""'");
  }
  arg8 = reinterpret_cast< char * >(buf8);
  res9 = SWIG_AsCharPtrAndSize(swig_obj[8], &buf9, NULL, &alloc9);
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "new_RawCom" "', argument " "9"" of type '" "char const *""'");
  }
  arg9 = reinterpret_cast< char * >(buf9);
  {
    try {
      result = (sword::RawCom *)new sword::RawCom((char const *)arg1,(char const *)arg2,(char const *)arg3,arg4,arg5,arg6,arg7,(char const *)arg8,(char const *)arg9); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__RawCom, SWIG_POINTER_NEW |  0 );
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  if (alloc8 == SWIG_NEWOBJ) delete[] buf8;
  if (alloc9 == SWIG_NEWOBJ) delete[] buf9;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  if (alloc8 == SWIG_NEWOBJ) delete[] buf8;
  if (alloc9 == SWIG_NEWOBJ) delete[] buf9;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RawCom__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  char *arg2 = 0 ;
  char *arg3 = 0 ;
  sword::SWDisplay *arg4 = 0 ;
  char arg5 ;
  char arg6 ;
  char arg7 ;
  char *arg8 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  char val5 ;
  int ecode5 = 0 ;
  char val6 ;
  int ecode6 = 0 ;
  char val7 ;
  int ecode7 = 0 ;
  int res8 ;
  char *buf8 = 0 ;
  int alloc8 = 0 ;
  sword::RawCom *result = 0 ;
  
  (void)self;
  if ((nobjs < 8) || (nobjs > 8)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_RawCom" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_RawCom" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_RawCom" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_sword__SWDisplay, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_RawCom" "', argument " "4"" of type '" "sword::SWDisplay *""'"); 
  }
  arg4 = reinterpret_cast< sword::SWDisplay * >(argp4);
  ecode5 = SWIG_AsVal_char(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_RawCom" "', argument " "5"" of type '" "char""'");
  } 
  arg5 = static_cast< char >(val5);
  ecode6 = SWIG_AsVal_char(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_RawCom" "', argument " "6"" of type '" "char""'");
  } 
  arg6 = static_cast< char >(val6);
  ecode7 = SWIG_AsVal_char(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_RawCom" "', argument " "7"" of type '" "char""'");
  } 
  arg7 = static_cast< char >(val7);
  res8 = SWIG_AsCharPtrAndSize(swig_obj[7], &buf8, NULL, &alloc8);
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "new_RawCom" "', argument " "8"" of type '" "char const *""'");
  }
  arg8 = reinterpret_cast< char * >(buf8);
  {
    try {
      result = (sword::RawCom *)new sword::RawCom((char const *)arg1,(char const *)arg2,(char const *)arg3,arg4,arg5,arg6,arg7,(char const *)arg8); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__RawCom, SWIG_POINTER_NEW |  0 );
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  if (alloc8 == SWIG_NEWOBJ) delete[] buf8;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  if (alloc8 == SWIG_NEWOBJ) delete[] buf8;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RawCom__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  char *arg2 = 0 ;
  char *arg3 = 0 ;
  sword::SWDisplay *arg4 = 0 ;
  char arg5 ;
  char arg6 ;
  char arg7 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  char val5 ;
  int ecode5 = 0 ;
  char val6 ;
  int ecode6 = 0 ;
  char val7 ;
  int ecode7 = 0 ;
  sword::RawCom *result = 0 ;
  
  (void)self;
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_RawCom" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_RawCom" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_RawCom" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_sword__SWDisplay, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_RawCom" "', argument " "4"" of type '" "sword::SWDisplay *""'"); 
  }
  arg4 = reinterpret_cast< sword::SWDisplay * >(argp4);
  ecode5 = SWIG_AsVal_char(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_RawCom" "', argument " "5"" of type '" "char""'");
  } 
  arg5 = static_cast< char >(val5);
  ecode6 = SWIG_AsVal_char(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_RawCom" "', argument " "6"" of type '" "char""'");
  } 
  arg6 = static_cast< char >(val6);
  ecode7 = SWIG_AsVal_char(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_RawCom" "', argument " "7"" of type '" "char""'");
  } 
  arg7 = static_cast< char >(val7);
  {
    try {
      result = (sword::RawCom *)new sword::RawCom((char const *)arg1,(char const *)arg2,(char const *)arg3,arg4,arg5,arg6,arg7); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__RawCom, SWIG_POINTER_NEW |  0 );
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RawCom__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  char *arg2 = 0 ;
  char *arg3 = 0 ;
  sword::SWDisplay *arg4 = 0 ;
  char arg5 ;
  char arg6 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  char val5 ;
  int ecode5 = 0 ;
  char val6 ;
  int ecode6 = 0 ;
  sword::RawCom *result = 0 ;
  
  (void)self;
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_RawCom" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_RawCom" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_RawCom" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_sword__SWDisplay, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_RawCom" "', argument " "4"" of type '" "sword::SWDisplay *""'"); 
  }
  arg4 = reinterpret_cast< sword::SWDisplay * >(argp4);
  ecode5 = SWIG_AsVal_char(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_RawCom" "', argument " "5"" of type '" "char""'");
  } 
  arg5 = static_cast< char >(val5);
  ecode6 = SWIG_AsVal_char(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_RawCom" "', argument " "6"" of type '" "char""'");
  } 
  arg6 = static_cast< char >(val6);
  {
    try {
      result = (sword::RawCom *)new sword::RawCom((char const *)arg1,(char const *)arg2,(char const *)arg3,arg4,arg5,arg6); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__RawCom, SWIG_POINTER_NEW |  0 );
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RawCom__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  char *arg2 = 0 ;
  char *arg3 = 0 ;
  sword::SWDisplay *arg4 = 0 ;
  char arg5 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  char val5 ;
  int ecode5 = 0 ;
  sword::RawCom *result = 0 ;
  
  (void)self;
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_RawCom" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_RawCom" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_RawCom" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_sword__SWDisplay, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_RawCom" "', argument " "4"" of type '" "sword::SWDisplay *""'"); 
  }
  arg4 = reinterpret_cast< sword::SWDisplay * >(argp4);
  ecode5 = SWIG_AsVal_char(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_RawCom" "', argument " "5"" of type '" "char""'");
  } 
  arg5 = static_cast< char >(val5);
  {
    try {
      result = (sword::RawCom *)new sword::RawCom((char const *)arg1,(char const *)arg2,(char const *)arg3,arg4,arg5); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__RawCom, SWIG_POINTER_NEW |  0 );
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RawCom__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  char *arg2 = 0 ;
  char *arg3 = 0 ;
  sword::SWDisplay *arg4 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  sword::RawCom *result = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_RawCom" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_RawCom" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_RawCom" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_sword__SWDisplay, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_RawCom" "', argument " "4"" of type '" "sword::SWDisplay *""'"); 
  }
  arg4 = reinterpret_cast< sword::SWDisplay * >(argp4);
  {
    try {
      result = (sword::RawCom *)new sword::RawCom((char const *)arg1,(char const *)arg2,(char const *)arg3,arg4); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__RawCom, SWIG_POINTER_NEW |  0 );
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RawCom__SWIG_6(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  char *arg2 = 0 ;
  char *arg3 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  sword::RawCom *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_RawCom" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_RawCom" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_RawCom" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  {
    try {
      result = (sword::RawCom *)new sword::RawCom((char const *)arg1,(char const *)arg2,(char const *)arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__RawCom, SWIG_POINTER_NEW |  0 );
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RawCom__SWIG_7(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  char *arg2 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  sword::RawCom *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_RawCom" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_RawCom" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    try {
      result = (sword::RawCom *)new sword::RawCom((char const *)arg1,(char const *)arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__RawCom, SWIG_POINTER_NEW |  0 );
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RawCom__SWIG_8(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  sword::RawCom *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_RawCom" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  {
    try {
      result = (sword::RawCom *)new sword::RawCom((char const *)arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__RawCom, SWIG_POINTER_NEW |  0 );
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RawCom(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[10] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_RawCom", 0, 9, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_RawCom__SWIG_8(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_RawCom__SWIG_7(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_new_RawCom__SWIG_6(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_sword__SWDisplay, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_new_RawCom__SWIG_5(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_sword__SWDisplay, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_char(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_new_RawCom__SWIG_4(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_sword__SWDisplay, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_char(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_char(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_new_RawCom__SWIG_3(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v = 0;
    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_sword__SWDisplay, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_char(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_char(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_char(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_new_RawCom__SWIG_2(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v = 0;
    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_sword__SWDisplay, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_char(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_char(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_char(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  int res = SWIG_AsCharPtrAndSize(argv[7], 0, NULL, 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    return _wrap_new_RawCom__SWIG_1(self, argc, argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v = 0;
    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_sword__SWDisplay, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_char(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_char(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_char(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  int res = SWIG_AsCharPtrAndSize(argv[7], 0, NULL, 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    int res = SWIG_AsCharPtrAndSize(argv[8], 0, NULL, 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      return _wrap_new_RawCom__SWIG_0(self, argc, argv);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_RawCom'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    sword::RawCom::RawCom(char const *,char const *,char const *,sword::SWDisplay *,char,char,char,char const *,char const *)\n"
    "    sword::RawCom::RawCom(char const *,char const *,char const *,sword::SWDisplay *,char,char,char,char const *)\n"
    "    sword::RawCom::RawCom(char const *,char const *,char const *,sword::SWDisplay *,char,char,char)\n"
    "    sword::RawCom::RawCom(char const *,char const *,char const *,sword::SWDisplay *,char,char)\n"
    "    sword::RawCom::RawCom(char const *,char const *,char const *,sword::SWDisplay *,char)\n"
    "    sword::RawCom::RawCom(char const *,char const *,char const *,sword::SWDisplay *)\n"
    "    sword::RawCom::RawCom(char const *,char const *,char const *)\n"
    "    sword::RawCom::RawCom(char const *,char const *)\n"
    "    sword::RawCom::RawCom(char const *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_RawCom(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::RawCom *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__RawCom, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RawCom" "', argument " "1"" of type '" "sword::RawCom *""'"); 
  }
  arg1 = reinterpret_cast< sword::RawCom * >(argp1);
  {
    try {
      delete arg1; 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RawCom_getRawEntryBuf(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::RawCom *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  sword::SWBuf *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__RawCom, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RawCom_getRawEntryBuf" "', argument " "1"" of type '" "sword::RawCom const *""'"); 
  }
  arg1 = reinterpret_cast< sword::RawCom * >(argp1);
  {
    try {
      result = (sword::SWBuf *) &((sword::RawCom const *)arg1)->getRawEntryBuf(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__SWBuf, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RawCom_increment__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::RawCom *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__RawCom, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RawCom_increment" "', argument " "1"" of type '" "sword::RawCom *""'"); 
  }
  arg1 = reinterpret_cast< sword::RawCom * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RawCom_increment" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    try {
      (arg1)->increment(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RawCom_increment__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::RawCom *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__RawCom, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RawCom_increment" "', argument " "1"" of type '" "sword::RawCom *""'"); 
  }
  arg1 = reinterpret_cast< sword::RawCom * >(argp1);
  {
    try {
      (arg1)->increment(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RawCom_increment(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "RawCom_increment", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__RawCom, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_RawCom_increment__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__RawCom, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_RawCom_increment__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'RawCom_increment'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    sword::RawCom::increment(int)\n"
    "    sword::RawCom::increment()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_RawCom_decrement__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::RawCom *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__RawCom, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RawCom_decrement" "', argument " "1"" of type '" "sword::RawCom *""'"); 
  }
  arg1 = reinterpret_cast< sword::RawCom * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RawCom_decrement" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    try {
      (arg1)->decrement(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RawCom_decrement__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::RawCom *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__RawCom, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RawCom_decrement" "', argument " "1"" of type '" "sword::RawCom *""'"); 
  }
  arg1 = reinterpret_cast< sword::RawCom * >(argp1);
  {
    try {
      (arg1)->decrement(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RawCom_decrement(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "RawCom_decrement", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__RawCom, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_RawCom_decrement__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__RawCom, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_RawCom_decrement__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'RawCom_decrement'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    sword::RawCom::decrement(int)\n"
    "    sword::RawCom::decrement()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_RawCom_isWritable(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::RawCom *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__RawCom, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RawCom_isWritable" "', argument " "1"" of type '" "sword::RawCom const *""'"); 
  }
  arg1 = reinterpret_cast< sword::RawCom * >(argp1);
  {
    try {
      result = (bool)((sword::RawCom const *)arg1)->isWritable(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RawCom_createModule__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  char *arg2 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  char result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RawCom_createModule" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RawCom_createModule" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    try {
      result = (char)sword::RawCom::createModule((char const *)arg1,(char const *)arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_char(static_cast< char >(result));
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_RawCom_createModule__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  char result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RawCom_createModule" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  {
    try {
      result = (char)sword::RawCom::createModule((char const *)arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_char(static_cast< char >(result));
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_RawCom_createModule(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "RawCom_createModule", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_RawCom_createModule__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_RawCom_createModule__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'RawCom_createModule'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    sword::RawCom::createModule(char const *,char const *)\n"
    "    sword::RawCom::createModule(char const *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_RawCom_setEntry__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::RawCom *arg1 = 0 ;
  char *arg2 = 0 ;
  long arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  long val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__RawCom, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RawCom_setEntry" "', argument " "1"" of type '" "sword::RawCom *""'"); 
  }
  arg1 = reinterpret_cast< sword::RawCom * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RawCom_setEntry" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  ecode3 = SWIG_AsVal_long(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RawCom_setEntry" "', argument " "3"" of type '" "long""'");
  } 
  arg3 = static_cast< long >(val3);
  {
    try {
      (arg1)->setEntry((char const *)arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_RawCom_setEntry__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::RawCom *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__RawCom, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RawCom_setEntry" "', argument " "1"" of type '" "sword::RawCom *""'"); 
  }
  arg1 = reinterpret_cast< sword::RawCom * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RawCom_setEntry" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    try {
      (arg1)->setEntry((char const *)arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_RawCom_setEntry(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "RawCom_setEntry", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__RawCom, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_RawCom_setEntry__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__RawCom, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_long(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_RawCom_setEntry__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'RawCom_setEntry'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    sword::RawCom::setEntry(char const *,long)\n"
    "    sword::RawCom::setEntry(char const *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_RawCom_linkEntry(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::RawCom *arg1 = 0 ;
  sword::SWKey *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "RawCom_linkEntry", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__RawCom, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RawCom_linkEntry" "', argument " "1"" of type '" "sword::RawCom *""'"); 
  }
  arg1 = reinterpret_cast< sword::RawCom * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_sword__SWKey, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RawCom_linkEntry" "', argument " "2"" of type '" "sword::SWKey const *""'"); 
  }
  arg2 = reinterpret_cast< sword::SWKey * >(argp2);
  {
    try {
      (arg1)->linkEntry((sword::SWKey const *)arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RawCom_deleteEntry(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::RawCom *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__RawCom, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RawCom_deleteEntry" "', argument " "1"" of type '" "sword::RawCom *""'"); 
  }
  arg1 = reinterpret_cast< sword::RawCom * >(argp1);
  {
    try {
      (arg1)->deleteEntry(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RawCom_isLinked(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::RawCom *arg1 = 0 ;
  sword::SWKey *arg2 = 0 ;
  sword::SWKey *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "RawCom_isLinked", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__RawCom, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RawCom_isLinked" "', argument " "1"" of type '" "sword::RawCom const *""'"); 
  }
  arg1 = reinterpret_cast< sword::RawCom * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_sword__SWKey, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RawCom_isLinked" "', argument " "2"" of type '" "sword::SWKey const *""'"); 
  }
  arg2 = reinterpret_cast< sword::SWKey * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_sword__SWKey, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RawCom_isLinked" "', argument " "3"" of type '" "sword::SWKey const *""'"); 
  }
  arg3 = reinterpret_cast< sword::SWKey * >(argp3);
  {
    try {
      result = (bool)((sword::RawCom const *)arg1)->isLinked((sword::SWKey const *)arg2,(sword::SWKey const *)arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RawCom_hasEntry(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::RawCom *arg1 = 0 ;
  sword::SWKey *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "RawCom_hasEntry", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__RawCom, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RawCom_hasEntry" "', argument " "1"" of type '" "sword::RawCom const *""'"); 
  }
  arg1 = reinterpret_cast< sword::RawCom * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_sword__SWKey, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RawCom_hasEntry" "', argument " "2"" of type '" "sword::SWKey const *""'"); 
  }
  arg2 = reinterpret_cast< sword::SWKey * >(argp2);
  {
    try {
      result = (bool)((sword::RawCom const *)arg1)->hasEntry((sword::SWKey const *)arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RawCom___lshift____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::RawCom *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  sword::SWModule *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__RawCom, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RawCom___lshift__" "', argument " "1"" of type '" "sword::RawCom *""'"); 
  }
  arg1 = reinterpret_cast< sword::RawCom * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RawCom___lshift__" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    try {
      result = (sword::SWModule *) &(arg1)->operator <<((char const *)arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__SWModule, 0 |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_RawCom___lshift____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::RawCom *arg1 = 0 ;
  sword::SWKey *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  sword::SWModule *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__RawCom, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RawCom___lshift__" "', argument " "1"" of type '" "sword::RawCom *""'"); 
  }
  arg1 = reinterpret_cast< sword::RawCom * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_sword__SWKey, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RawCom___lshift__" "', argument " "2"" of type '" "sword::SWKey const *""'"); 
  }
  arg2 = reinterpret_cast< sword::SWKey * >(argp2);
  {
    try {
      result = (sword::SWModule *) &(arg1)->operator <<((sword::SWKey const *)arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__SWModule, 0 |  0 );
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_RawCom___lshift__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "RawCom___lshift__", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__RawCom, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_sword__SWKey, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_RawCom___lshift____SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__RawCom, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_RawCom___lshift____SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_RawCom___isub__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::RawCom *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  sword::SWModule *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "RawCom___isub__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__RawCom, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RawCom___isub__" "', argument " "1"" of type '" "sword::RawCom *""'"); 
  }
  arg1 = reinterpret_cast< sword::RawCom * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RawCom___isub__" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    try {
      result = (sword::SWModule *) &(arg1)->operator -=(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__SWModule, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RawCom___iadd__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::RawCom *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  sword::SWModule *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "RawCom___iadd__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__RawCom, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RawCom___iadd__" "', argument " "1"" of type '" "sword::RawCom *""'"); 
  }
  arg1 = reinterpret_cast< sword::RawCom * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RawCom___iadd__" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    try {
      result = (sword::SWModule *) &(arg1)->operator +=(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__SWModule, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RawCom_castTo(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWModule *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  sword::RawCom *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RawCom_castTo" "', argument " "1"" of type '" "sword::SWModule *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWModule * >(argp1);
  {
    try {
      result = (sword::RawCom *)sword_RawCom_castTo(arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__RawCom, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *RawCom_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_sword__RawCom, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *RawCom_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_zCom__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  char *arg2 = 0 ;
  char *arg3 = 0 ;
  int arg4 ;
  sword::SWCompress *arg5 = 0 ;
  sword::SWDisplay *arg6 = 0 ;
  char arg7 ;
  char arg8 ;
  char arg9 ;
  char *arg10 = 0 ;
  char *arg11 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  char val7 ;
  int ecode7 = 0 ;
  char val8 ;
  int ecode8 = 0 ;
  char val9 ;
  int ecode9 = 0 ;
  int res10 ;
  char *buf10 = 0 ;
  int alloc10 = 0 ;
  int res11 ;
  char *buf11 = 0 ;
  int alloc11 = 0 ;
  sword::zCom *result = 0 ;
  
  (void)self;
  if ((nobjs < 11) || (nobjs > 11)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_zCom" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_zCom" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_zCom" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_zCom" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5,SWIGTYPE_p_sword__SWCompress, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_zCom" "', argument " "5"" of type '" "sword::SWCompress *""'"); 
  }
  arg5 = reinterpret_cast< sword::SWCompress * >(argp5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6,SWIGTYPE_p_sword__SWDisplay, 0 |  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_zCom" "', argument " "6"" of type '" "sword::SWDisplay *""'"); 
  }
  arg6 = reinterpret_cast< sword::SWDisplay * >(argp6);
  ecode7 = SWIG_AsVal_char(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_zCom" "', argument " "7"" of type '" "char""'");
  } 
  arg7 = static_cast< char >(val7);
  ecode8 = SWIG_AsVal_char(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_zCom" "', argument " "8"" of type '" "char""'");
  } 
  arg8 = static_cast< char >(val8);
  ecode9 = SWIG_AsVal_char(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_zCom" "', argument " "9"" of type '" "char""'");
  } 
  arg9 = static_cast< char >(val9);
  res10 = SWIG_AsCharPtrAndSize(swig_obj[9], &buf10, NULL, &alloc10);
  if (!SWIG_IsOK(res10)) {
    SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "new_zCom" "', argument " "10"" of type '" "char const *""'");
  }
  arg10 = reinterpret_cast< char * >(buf10);
  res11 = SWIG_AsCharPtrAndSize(swig_obj[10], &buf11, NULL, &alloc11);
  if (!SWIG_IsOK(res11)) {
    SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "new_zCom" "', argument " "11"" of type '" "char const *""'");
  }
  arg11 = reinterpret_cast< char * >(buf11);
  {
    try {
      result = (sword::zCom *)new sword::zCom((char const *)arg1,(char const *)arg2,(char const *)arg3,arg4,arg5,arg6,arg7,arg8,arg9,(char const *)arg10,(char const *)arg11); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__zCom, SWIG_POINTER_NEW |  0 );
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  if (alloc10 == SWIG_NEWOBJ) delete[] buf10;
  if (alloc11 == SWIG_NEWOBJ) delete[] buf11;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  if (alloc10 == SWIG_NEWOBJ) delete[] buf10;
  if (alloc11 == SWIG_NEWOBJ) delete[] buf11;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_zCom__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  char *arg2 = 0 ;
  char *arg3 = 0 ;
  int arg4 ;
  sword::SWCompress *arg5 = 0 ;
  sword::SWDisplay *arg6 = 0 ;
  char arg7 ;
  char arg8 ;
  char arg9 ;
  char *arg10 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  char val7 ;
  int ecode7 = 0 ;
  char val8 ;
  int ecode8 = 0 ;
  char val9 ;
  int ecode9 = 0 ;
  int res10 ;
  char *buf10 = 0 ;
  int alloc10 = 0 ;
  sword::zCom *result = 0 ;
  
  (void)self;
  if ((nobjs < 10) || (nobjs > 10)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_zCom" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_zCom" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_zCom" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_zCom" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5,SWIGTYPE_p_sword__SWCompress, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_zCom" "', argument " "5"" of type '" "sword::SWCompress *""'"); 
  }
  arg5 = reinterpret_cast< sword::SWCompress * >(argp5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6,SWIGTYPE_p_sword__SWDisplay, 0 |  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_zCom" "', argument " "6"" of type '" "sword::SWDisplay *""'"); 
  }
  arg6 = reinterpret_cast< sword::SWDisplay * >(argp6);
  ecode7 = SWIG_AsVal_char(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_zCom" "', argument " "7"" of type '" "char""'");
  } 
  arg7 = static_cast< char >(val7);
  ecode8 = SWIG_AsVal_char(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_zCom" "', argument " "8"" of type '" "char""'");
  } 
  arg8 = static_cast< char >(val8);
  ecode9 = SWIG_AsVal_char(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_zCom" "', argument " "9"" of type '" "char""'");
  } 
  arg9 = static_cast< char >(val9);
  res10 = SWIG_AsCharPtrAndSize(swig_obj[9], &buf10, NULL, &alloc10);
  if (!SWIG_IsOK(res10)) {
    SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "new_zCom" "', argument " "10"" of type '" "char const *""'");
  }
  arg10 = reinterpret_cast< char * >(buf10);
  {
    try {
      result = (sword::zCom *)new sword::zCom((char const *)arg1,(char const *)arg2,(char const *)arg3,arg4,arg5,arg6,arg7,arg8,arg9,(char const *)arg10); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__zCom, SWIG_POINTER_NEW |  0 );
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  if (alloc10 == SWIG_NEWOBJ) delete[] buf10;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  if (alloc10 == SWIG_NEWOBJ) delete[] buf10;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_zCom__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  char *arg2 = 0 ;
  char *arg3 = 0 ;
  int arg4 ;
  sword::SWCompress *arg5 = 0 ;
  sword::SWDisplay *arg6 = 0 ;
  char arg7 ;
  char arg8 ;
  char arg9 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  char val7 ;
  int ecode7 = 0 ;
  char val8 ;
  int ecode8 = 0 ;
  char val9 ;
  int ecode9 = 0 ;
  sword::zCom *result = 0 ;
  
  (void)self;
  if ((nobjs < 9) || (nobjs > 9)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_zCom" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_zCom" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_zCom" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_zCom" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5,SWIGTYPE_p_sword__SWCompress, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_zCom" "', argument " "5"" of type '" "sword::SWCompress *""'"); 
  }
  arg5 = reinterpret_cast< sword::SWCompress * >(argp5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6,SWIGTYPE_p_sword__SWDisplay, 0 |  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_zCom" "', argument " "6"" of type '" "sword::SWDisplay *""'"); 
  }
  arg6 = reinterpret_cast< sword::SWDisplay * >(argp6);
  ecode7 = SWIG_AsVal_char(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_zCom" "', argument " "7"" of type '" "char""'");
  } 
  arg7 = static_cast< char >(val7);
  ecode8 = SWIG_AsVal_char(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_zCom" "', argument " "8"" of type '" "char""'");
  } 
  arg8 = static_cast< char >(val8);
  ecode9 = SWIG_AsVal_char(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_zCom" "', argument " "9"" of type '" "char""'");
  } 
  arg9 = static_cast< char >(val9);
  {
    try {
      result = (sword::zCom *)new sword::zCom((char const *)arg1,(char const *)arg2,(char const *)arg3,arg4,arg5,arg6,arg7,arg8,arg9); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__zCom, SWIG_POINTER_NEW |  0 );
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_zCom__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  char *arg2 = 0 ;
  char *arg3 = 0 ;
  int arg4 ;
  sword::SWCompress *arg5 = 0 ;
  sword::SWDisplay *arg6 = 0 ;
  char arg7 ;
  char arg8 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  char val7 ;
  int ecode7 = 0 ;
  char val8 ;
  int ecode8 = 0 ;
  sword::zCom *result = 0 ;
  
  (void)self;
  if ((nobjs < 8) || (nobjs > 8)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_zCom" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_zCom" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_zCom" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_zCom" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5,SWIGTYPE_p_sword__SWCompress, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_zCom" "', argument " "5"" of type '" "sword::SWCompress *""'"); 
  }
  arg5 = reinterpret_cast< sword::SWCompress * >(argp5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6,SWIGTYPE_p_sword__SWDisplay, 0 |  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_zCom" "', argument " "6"" of type '" "sword::SWDisplay *""'"); 
  }
  arg6 = reinterpret_cast< sword::SWDisplay * >(argp6);
  ecode7 = SWIG_AsVal_char(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_zCom" "', argument " "7"" of type '" "char""'");
  } 
  arg7 = static_cast< char >(val7);
  ecode8 = SWIG_AsVal_char(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_zCom" "', argument " "8"" of type '" "char""'");
  } 
  arg8 = static_cast< char >(val8);
  {
    try {
      result = (sword::zCom *)new sword::zCom((char const *)arg1,(char const *)arg2,(char const *)arg3,arg4,arg5,arg6,arg7,arg8); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__zCom, SWIG_POINTER_NEW |  0 );
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_zCom__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  char *arg2 = 0 ;
  char *arg3 = 0 ;
  int arg4 ;
  sword::SWCompress *arg5 = 0 ;
  sword::SWDisplay *arg6 = 0 ;
  char arg7 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  char val7 ;
  int ecode7 = 0 ;
  sword::zCom *result = 0 ;
  
  (void)self;
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_zCom" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_zCom" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_zCom" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_zCom" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5,SWIGTYPE_p_sword__SWCompress, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_zCom" "', argument " "5"" of type '" "sword::SWCompress *""'"); 
  }
  arg5 = reinterpret_cast< sword::SWCompress * >(argp5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6,SWIGTYPE_p_sword__SWDisplay, 0 |  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_zCom" "', argument " "6"" of type '" "sword::SWDisplay *""'"); 
  }
  arg6 = reinterpret_cast< sword::SWDisplay * >(argp6);
  ecode7 = SWIG_AsVal_char(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_zCom" "', argument " "7"" of type '" "char""'");
  } 
  arg7 = static_cast< char >(val7);
  {
    try {
      result = (sword::zCom *)new sword::zCom((char const *)arg1,(char const *)arg2,(char const *)arg3,arg4,arg5,arg6,arg7); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__zCom, SWIG_POINTER_NEW |  0 );
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_zCom__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  char *arg2 = 0 ;
  char *arg3 = 0 ;
  int arg4 ;
  sword::SWCompress *arg5 = 0 ;
  sword::SWDisplay *arg6 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  sword::zCom *result = 0 ;
  
  (void)self;
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_zCom" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_zCom" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_zCom" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_zCom" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5,SWIGTYPE_p_sword__SWCompress, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_zCom" "', argument " "5"" of type '" "sword::SWCompress *""'"); 
  }
  arg5 = reinterpret_cast< sword::SWCompress * >(argp5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6,SWIGTYPE_p_sword__SWDisplay, 0 |  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_zCom" "', argument " "6"" of type '" "sword::SWDisplay *""'"); 
  }
  arg6 = reinterpret_cast< sword::SWDisplay * >(argp6);
  {
    try {
      result = (sword::zCom *)new sword::zCom((char const *)arg1,(char const *)arg2,(char const *)arg3,arg4,arg5,arg6); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__zCom, SWIG_POINTER_NEW |  0 );
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_zCom__SWIG_6(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  char *arg2 = 0 ;
  char *arg3 = 0 ;
  int arg4 ;
  sword::SWCompress *arg5 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  sword::zCom *result = 0 ;
  
  (void)self;
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_zCom" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_zCom" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_zCom" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_zCom" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5,SWIGTYPE_p_sword__SWCompress, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_zCom" "', argument " "5"" of type '" "sword::SWCompress *""'"); 
  }
  arg5 = reinterpret_cast< sword::SWCompress * >(argp5);
  {
    try {
      result = (sword::zCom *)new sword::zCom((char const *)arg1,(char const *)arg2,(char const *)arg3,arg4,arg5); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__zCom, SWIG_POINTER_NEW |  0 );
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_zCom__SWIG_7(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  char *arg2 = 0 ;
  char *arg3 = 0 ;
  int arg4 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  sword::zCom *result = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_zCom" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_zCom" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_zCom" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_zCom" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  {
    try {
      result = (sword::zCom *)new sword::zCom((char const *)arg1,(char const *)arg2,(char const *)arg3,arg4); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__zCom, SWIG_POINTER_NEW |  0 );
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_zCom__SWIG_8(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  char *arg2 = 0 ;
  char *arg3 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  sword::zCom *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_zCom" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_zCom" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_zCom" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  {
    try {
      result = (sword::zCom *)new sword::zCom((char const *)arg1,(char const *)arg2,(char const *)arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__zCom, SWIG_POINTER_NEW |  0 );
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_zCom__SWIG_9(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  char *arg2 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  sword::zCom *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_zCom" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_zCom" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    try {
      result = (sword::zCom *)new sword::zCom((char const *)arg1,(char const *)arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__zCom, SWIG_POINTER_NEW |  0 );
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_zCom__SWIG_10(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  sword::zCom *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_zCom" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  {
    try {
      result = (sword::zCom *)new sword::zCom((char const *)arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__zCom, SWIG_POINTER_NEW |  0 );
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_zCom(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[12] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_zCom", 0, 11, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_zCom__SWIG_10(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_zCom__SWIG_9(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_new_zCom__SWIG_8(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_new_zCom__SWIG_7(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_sword__SWCompress, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_new_zCom__SWIG_6(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_sword__SWCompress, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_sword__SWDisplay, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                return _wrap_new_zCom__SWIG_5(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v = 0;
    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_sword__SWCompress, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_sword__SWDisplay, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_char(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_new_zCom__SWIG_4(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v = 0;
    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_sword__SWCompress, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_sword__SWDisplay, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_char(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_char(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    return _wrap_new_zCom__SWIG_3(self, argc, argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v = 0;
    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_sword__SWCompress, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_sword__SWDisplay, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_char(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_char(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_char(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      return _wrap_new_zCom__SWIG_2(self, argc, argv);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 10) {
    int _v = 0;
    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_sword__SWCompress, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_sword__SWDisplay, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_char(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_char(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_char(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      int res = SWIG_AsCharPtrAndSize(argv[9], 0, NULL, 0);
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        return _wrap_new_zCom__SWIG_1(self, argc, argv);
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 11) {
    int _v = 0;
    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_sword__SWCompress, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_sword__SWDisplay, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_char(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_char(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_char(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      int res = SWIG_AsCharPtrAndSize(argv[9], 0, NULL, 0);
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        int res = SWIG_AsCharPtrAndSize(argv[10], 0, NULL, 0);
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          return _wrap_new_zCom__SWIG_0(self, argc, argv);
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_zCom'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    sword::zCom::zCom(char const *,char const *,char const *,int,sword::SWCompress *,sword::SWDisplay *,char,char,char,char const *,char const *)\n"
    "    sword::zCom::zCom(char const *,char const *,char const *,int,sword::SWCompress *,sword::SWDisplay *,char,char,char,char const *)\n"
    "    sword::zCom::zCom(char const *,char const *,char const *,int,sword::SWCompress *,sword::SWDisplay *,char,char,char)\n"
    "    sword::zCom::zCom(char const *,char const *,char const *,int,sword::SWCompress *,sword::SWDisplay *,char,char)\n"
    "    sword::zCom::zCom(char const *,char const *,char const *,int,sword::SWCompress *,sword::SWDisplay *,char)\n"
    "    sword::zCom::zCom(char const *,char const *,char const *,int,sword::SWCompress *,sword::SWDisplay *)\n"
    "    sword::zCom::zCom(char const *,char const *,char const *,int,sword::SWCompress *)\n"
    "    sword::zCom::zCom(char const *,char const *,char const *,int)\n"
    "    sword::zCom::zCom(char const *,char const *,char const *)\n"
    "    sword::zCom::zCom(char const *,char const *)\n"
    "    sword::zCom::zCom(char const *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_zCom(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::zCom *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__zCom, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_zCom" "', argument " "1"" of type '" "sword::zCom *""'"); 
  }
  arg1 = reinterpret_cast< sword::zCom * >(argp1);
  {
    try {
      delete arg1; 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_zCom_getRawEntryBuf(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::zCom *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  sword::SWBuf *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__zCom, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "zCom_getRawEntryBuf" "', argument " "1"" of type '" "sword::zCom const *""'"); 
  }
  arg1 = reinterpret_cast< sword::zCom * >(argp1);
  {
    try {
      result = (sword::SWBuf *) &((sword::zCom const *)arg1)->getRawEntryBuf(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__SWBuf, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_zCom_increment__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::zCom *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__zCom, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "zCom_increment" "', argument " "1"" of type '" "sword::zCom *""'"); 
  }
  arg1 = reinterpret_cast< sword::zCom * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "zCom_increment" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    try {
      (arg1)->increment(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_zCom_increment__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::zCom *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__zCom, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "zCom_increment" "', argument " "1"" of type '" "sword::zCom *""'"); 
  }
  arg1 = reinterpret_cast< sword::zCom * >(argp1);
  {
    try {
      (arg1)->increment(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_zCom_increment(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "zCom_increment", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__zCom, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_zCom_increment__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__zCom, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_zCom_increment__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'zCom_increment'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    sword::zCom::increment(int)\n"
    "    sword::zCom::increment()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_zCom_decrement__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::zCom *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__zCom, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "zCom_decrement" "', argument " "1"" of type '" "sword::zCom *""'"); 
  }
  arg1 = reinterpret_cast< sword::zCom * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "zCom_decrement" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    try {
      (arg1)->decrement(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_zCom_decrement__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::zCom *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__zCom, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "zCom_decrement" "', argument " "1"" of type '" "sword::zCom *""'"); 
  }
  arg1 = reinterpret_cast< sword::zCom * >(argp1);
  {
    try {
      (arg1)->decrement(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_zCom_decrement(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "zCom_decrement", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__zCom, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_zCom_decrement__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__zCom, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_zCom_decrement__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'zCom_decrement'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    sword::zCom::decrement(int)\n"
    "    sword::zCom::decrement()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_zCom_isWritable(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::zCom *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__zCom, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "zCom_isWritable" "', argument " "1"" of type '" "sword::zCom const *""'"); 
  }
  arg1 = reinterpret_cast< sword::zCom * >(argp1);
  {
    try {
      result = (bool)((sword::zCom const *)arg1)->isWritable(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_zCom_createModule__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  int arg2 ;
  char *arg3 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  char result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "zCom_createModule" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "zCom_createModule" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "zCom_createModule" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  {
    try {
      result = (char)sword::zCom::createModule((char const *)arg1,arg2,(char const *)arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_char(static_cast< char >(result));
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_zCom_createModule__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  int arg2 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  char result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "zCom_createModule" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "zCom_createModule" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    try {
      result = (char)sword::zCom::createModule((char const *)arg1,arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_char(static_cast< char >(result));
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_zCom_createModule(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "zCom_createModule", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_zCom_createModule__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_zCom_createModule__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'zCom_createModule'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    sword::zCom::createModule(char const *,int,char const *)\n"
    "    sword::zCom::createModule(char const *,int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_zCom_setEntry__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::zCom *arg1 = 0 ;
  char *arg2 = 0 ;
  long arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  long val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__zCom, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "zCom_setEntry" "', argument " "1"" of type '" "sword::zCom *""'"); 
  }
  arg1 = reinterpret_cast< sword::zCom * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "zCom_setEntry" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  ecode3 = SWIG_AsVal_long(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "zCom_setEntry" "', argument " "3"" of type '" "long""'");
  } 
  arg3 = static_cast< long >(val3);
  {
    try {
      (arg1)->setEntry((char const *)arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_zCom_setEntry__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::zCom *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__zCom, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "zCom_setEntry" "', argument " "1"" of type '" "sword::zCom *""'"); 
  }
  arg1 = reinterpret_cast< sword::zCom * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "zCom_setEntry" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    try {
      (arg1)->setEntry((char const *)arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_zCom_setEntry(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "zCom_setEntry", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__zCom, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_zCom_setEntry__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__zCom, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_long(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_zCom_setEntry__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'zCom_setEntry'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    sword::zCom::setEntry(char const *,long)\n"
    "    sword::zCom::setEntry(char const *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_zCom_linkEntry(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::zCom *arg1 = 0 ;
  sword::SWKey *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "zCom_linkEntry", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__zCom, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "zCom_linkEntry" "', argument " "1"" of type '" "sword::zCom *""'"); 
  }
  arg1 = reinterpret_cast< sword::zCom * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_sword__SWKey, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "zCom_linkEntry" "', argument " "2"" of type '" "sword::SWKey const *""'"); 
  }
  arg2 = reinterpret_cast< sword::SWKey * >(argp2);
  {
    try {
      (arg1)->linkEntry((sword::SWKey const *)arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_zCom_deleteEntry(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::zCom *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__zCom, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "zCom_deleteEntry" "', argument " "1"" of type '" "sword::zCom *""'"); 
  }
  arg1 = reinterpret_cast< sword::zCom * >(argp1);
  {
    try {
      (arg1)->deleteEntry(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_zCom_rawZFilter__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::zCom *arg1 = 0 ;
  sword::SWBuf *arg2 = 0 ;
  char arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  char val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__zCom, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "zCom_rawZFilter" "', argument " "1"" of type '" "sword::zCom const *""'"); 
  }
  arg1 = reinterpret_cast< sword::zCom * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_sword__SWBuf,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "zCom_rawZFilter" "', argument " "2"" of type '" "sword::SWBuf &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "zCom_rawZFilter" "', argument " "2"" of type '" "sword::SWBuf &""'"); 
  }
  arg2 = reinterpret_cast< sword::SWBuf * >(argp2);
  ecode3 = SWIG_AsVal_char(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "zCom_rawZFilter" "', argument " "3"" of type '" "char""'");
  } 
  arg3 = static_cast< char >(val3);
  {
    try {
      ((sword::zCom const *)arg1)->rawZFilter(*arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_zCom_rawZFilter__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::zCom *arg1 = 0 ;
  sword::SWBuf *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__zCom, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "zCom_rawZFilter" "', argument " "1"" of type '" "sword::zCom const *""'"); 
  }
  arg1 = reinterpret_cast< sword::zCom * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_sword__SWBuf,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "zCom_rawZFilter" "', argument " "2"" of type '" "sword::SWBuf &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "zCom_rawZFilter" "', argument " "2"" of type '" "sword::SWBuf &""'"); 
  }
  arg2 = reinterpret_cast< sword::SWBuf * >(argp2);
  {
    try {
      ((sword::zCom const *)arg1)->rawZFilter(*arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_zCom_rawZFilter(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "zCom_rawZFilter", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__zCom, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_sword__SWBuf, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_zCom_rawZFilter__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__zCom, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_sword__SWBuf, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_char(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_zCom_rawZFilter__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'zCom_rawZFilter'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    sword::zCom::rawZFilter(sword::SWBuf &,char) const\n"
    "    sword::zCom::rawZFilter(sword::SWBuf &) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_zCom_flush(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::zCom *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__zCom, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "zCom_flush" "', argument " "1"" of type '" "sword::zCom *""'"); 
  }
  arg1 = reinterpret_cast< sword::zCom * >(argp1);
  {
    try {
      (arg1)->flush(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_zCom_isLinked(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::zCom *arg1 = 0 ;
  sword::SWKey *arg2 = 0 ;
  sword::SWKey *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "zCom_isLinked", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__zCom, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "zCom_isLinked" "', argument " "1"" of type '" "sword::zCom const *""'"); 
  }
  arg1 = reinterpret_cast< sword::zCom * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_sword__SWKey, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "zCom_isLinked" "', argument " "2"" of type '" "sword::SWKey const *""'"); 
  }
  arg2 = reinterpret_cast< sword::SWKey * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_sword__SWKey, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "zCom_isLinked" "', argument " "3"" of type '" "sword::SWKey const *""'"); 
  }
  arg3 = reinterpret_cast< sword::SWKey * >(argp3);
  {
    try {
      result = (bool)((sword::zCom const *)arg1)->isLinked((sword::SWKey const *)arg2,(sword::SWKey const *)arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_zCom_hasEntry(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::zCom *arg1 = 0 ;
  sword::SWKey *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "zCom_hasEntry", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__zCom, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "zCom_hasEntry" "', argument " "1"" of type '" "sword::zCom const *""'"); 
  }
  arg1 = reinterpret_cast< sword::zCom * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_sword__SWKey, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "zCom_hasEntry" "', argument " "2"" of type '" "sword::SWKey const *""'"); 
  }
  arg2 = reinterpret_cast< sword::SWKey * >(argp2);
  {
    try {
      result = (bool)((sword::zCom const *)arg1)->hasEntry((sword::SWKey const *)arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_zCom___lshift____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::zCom *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  sword::SWModule *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__zCom, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "zCom___lshift__" "', argument " "1"" of type '" "sword::zCom *""'"); 
  }
  arg1 = reinterpret_cast< sword::zCom * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "zCom___lshift__" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    try {
      result = (sword::SWModule *) &(arg1)->operator <<((char const *)arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__SWModule, 0 |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_zCom___lshift____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::zCom *arg1 = 0 ;
  sword::SWKey *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  sword::SWModule *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__zCom, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "zCom___lshift__" "', argument " "1"" of type '" "sword::zCom *""'"); 
  }
  arg1 = reinterpret_cast< sword::zCom * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_sword__SWKey, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "zCom___lshift__" "', argument " "2"" of type '" "sword::SWKey const *""'"); 
  }
  arg2 = reinterpret_cast< sword::SWKey * >(argp2);
  {
    try {
      result = (sword::SWModule *) &(arg1)->operator <<((sword::SWKey const *)arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__SWModule, 0 |  0 );
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_zCom___lshift__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "zCom___lshift__", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__zCom, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_sword__SWKey, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_zCom___lshift____SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__zCom, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_zCom___lshift____SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_zCom___isub__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::zCom *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  sword::SWModule *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "zCom___isub__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__zCom, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "zCom___isub__" "', argument " "1"" of type '" "sword::zCom *""'"); 
  }
  arg1 = reinterpret_cast< sword::zCom * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "zCom___isub__" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    try {
      result = (sword::SWModule *) &(arg1)->operator -=(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__SWModule, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_zCom___iadd__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::zCom *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  sword::SWModule *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "zCom___iadd__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__zCom, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "zCom___iadd__" "', argument " "1"" of type '" "sword::zCom *""'"); 
  }
  arg1 = reinterpret_cast< sword::zCom * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "zCom___iadd__" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    try {
      result = (sword::SWModule *) &(arg1)->operator +=(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__SWModule, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_zCom_castTo(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWModule *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  sword::zCom *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "zCom_castTo" "', argument " "1"" of type '" "sword::SWModule *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWModule * >(argp1);
  {
    try {
      result = (sword::zCom *)sword_zCom_castTo(arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__zCom, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *zCom_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_sword__zCom, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *zCom_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_delete_SWGenBook(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWGenBook *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWGenBook, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SWGenBook" "', argument " "1"" of type '" "sword::SWGenBook *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWGenBook * >(argp1);
  {
    try {
      delete arg1; 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWGenBook_createKey(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWGenBook *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  sword::SWKey *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWGenBook, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWGenBook_createKey" "', argument " "1"" of type '" "sword::SWGenBook const *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWGenBook * >(argp1);
  {
    try {
      result = (sword::SWKey *)((sword::SWGenBook const *)arg1)->createKey(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__SWKey, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWGenBook___lshift____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::SWGenBook *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  sword::SWModule *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWGenBook, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWGenBook___lshift__" "', argument " "1"" of type '" "sword::SWGenBook *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWGenBook * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SWGenBook___lshift__" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    try {
      result = (sword::SWModule *) &(arg1)->operator <<((char const *)arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__SWModule, 0 |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SWGenBook___lshift____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::SWGenBook *arg1 = 0 ;
  sword::SWKey *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  sword::SWModule *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWGenBook, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWGenBook___lshift__" "', argument " "1"" of type '" "sword::SWGenBook *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWGenBook * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_sword__SWKey, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SWGenBook___lshift__" "', argument " "2"" of type '" "sword::SWKey const *""'"); 
  }
  arg2 = reinterpret_cast< sword::SWKey * >(argp2);
  {
    try {
      result = (sword::SWModule *) &(arg1)->operator <<((sword::SWKey const *)arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__SWModule, 0 |  0 );
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SWGenBook___lshift__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SWGenBook___lshift__", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__SWGenBook, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_sword__SWKey, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SWGenBook___lshift____SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__SWGenBook, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SWGenBook___lshift____SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SWGenBook___isub__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWGenBook *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  sword::SWModule *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SWGenBook___isub__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWGenBook, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWGenBook___isub__" "', argument " "1"" of type '" "sword::SWGenBook *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWGenBook * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SWGenBook___isub__" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    try {
      result = (sword::SWModule *) &(arg1)->operator -=(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__SWModule, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWGenBook___iadd__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWGenBook *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  sword::SWModule *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SWGenBook___iadd__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWGenBook, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWGenBook___iadd__" "', argument " "1"" of type '" "sword::SWGenBook *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWGenBook * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SWGenBook___iadd__" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    try {
      result = (sword::SWModule *) &(arg1)->operator +=(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__SWModule, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWGenBook_castTo(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWModule *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  sword::SWGenBook *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWGenBook_castTo" "', argument " "1"" of type '" "sword::SWModule *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWModule * >(argp1);
  {
    try {
      result = (sword::SWGenBook *)sword_SWGenBook_castTo(arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__SWGenBook, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SWGenBook_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_sword__SWGenBook, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_RawGenBook__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  char *arg2 = 0 ;
  char *arg3 = 0 ;
  sword::SWDisplay *arg4 = 0 ;
  char arg5 ;
  char arg6 ;
  char arg7 ;
  char *arg8 = 0 ;
  char *arg9 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  char val5 ;
  int ecode5 = 0 ;
  char val6 ;
  int ecode6 = 0 ;
  char val7 ;
  int ecode7 = 0 ;
  int res8 ;
  char *buf8 = 0 ;
  int alloc8 = 0 ;
  int res9 ;
  char *buf9 = 0 ;
  int alloc9 = 0 ;
  sword::RawGenBook *result = 0 ;
  
  (void)self;
  if ((nobjs < 9) || (nobjs > 9)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_RawGenBook" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_RawGenBook" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_RawGenBook" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_sword__SWDisplay, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_RawGenBook" "', argument " "4"" of type '" "sword::SWDisplay *""'"); 
  }
  arg4 = reinterpret_cast< sword::SWDisplay * >(argp4);
  ecode5 = SWIG_AsVal_char(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_RawGenBook" "', argument " "5"" of type '" "char""'");
  } 
  arg5 = static_cast< char >(val5);
  ecode6 = SWIG_AsVal_char(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_RawGenBook" "', argument " "6"" of type '" "char""'");
  } 
  arg6 = static_cast< char >(val6);
  ecode7 = SWIG_AsVal_char(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_RawGenBook" "', argument " "7"" of type '" "char""'");
  } 
  arg7 = static_cast< char >(val7);
  res8 = SWIG_AsCharPtrAndSize(swig_obj[7], &buf8, NULL, &alloc8);
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "new_RawGenBook" "', argument " "8"" of type '" "char const *""'");
  }
  arg8 = reinterpret_cast< char * >(buf8);
  res9 = SWIG_AsCharPtrAndSize(swig_obj[8], &buf9, NULL, &alloc9);
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "new_RawGenBook" "', argument " "9"" of type '" "char const *""'");
  }
  arg9 = reinterpret_cast< char * >(buf9);
  {
    try {
      result = (sword::RawGenBook *)new sword::RawGenBook((char const *)arg1,(char const *)arg2,(char const *)arg3,arg4,arg5,arg6,arg7,(char const *)arg8,(char const *)arg9); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__RawGenBook, SWIG_POINTER_NEW |  0 );
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  if (alloc8 == SWIG_NEWOBJ) delete[] buf8;
  if (alloc9 == SWIG_NEWOBJ) delete[] buf9;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  if (alloc8 == SWIG_NEWOBJ) delete[] buf8;
  if (alloc9 == SWIG_NEWOBJ) delete[] buf9;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RawGenBook__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  char *arg2 = 0 ;
  char *arg3 = 0 ;
  sword::SWDisplay *arg4 = 0 ;
  char arg5 ;
  char arg6 ;
  char arg7 ;
  char *arg8 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  char val5 ;
  int ecode5 = 0 ;
  char val6 ;
  int ecode6 = 0 ;
  char val7 ;
  int ecode7 = 0 ;
  int res8 ;
  char *buf8 = 0 ;
  int alloc8 = 0 ;
  sword::RawGenBook *result = 0 ;
  
  (void)self;
  if ((nobjs < 8) || (nobjs > 8)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_RawGenBook" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_RawGenBook" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_RawGenBook" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_sword__SWDisplay, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_RawGenBook" "', argument " "4"" of type '" "sword::SWDisplay *""'"); 
  }
  arg4 = reinterpret_cast< sword::SWDisplay * >(argp4);
  ecode5 = SWIG_AsVal_char(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_RawGenBook" "', argument " "5"" of type '" "char""'");
  } 
  arg5 = static_cast< char >(val5);
  ecode6 = SWIG_AsVal_char(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_RawGenBook" "', argument " "6"" of type '" "char""'");
  } 
  arg6 = static_cast< char >(val6);
  ecode7 = SWIG_AsVal_char(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_RawGenBook" "', argument " "7"" of type '" "char""'");
  } 
  arg7 = static_cast< char >(val7);
  res8 = SWIG_AsCharPtrAndSize(swig_obj[7], &buf8, NULL, &alloc8);
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "new_RawGenBook" "', argument " "8"" of type '" "char const *""'");
  }
  arg8 = reinterpret_cast< char * >(buf8);
  {
    try {
      result = (sword::RawGenBook *)new sword::RawGenBook((char const *)arg1,(char const *)arg2,(char const *)arg3,arg4,arg5,arg6,arg7,(char const *)arg8); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__RawGenBook, SWIG_POINTER_NEW |  0 );
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  if (alloc8 == SWIG_NEWOBJ) delete[] buf8;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  if (alloc8 == SWIG_NEWOBJ) delete[] buf8;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RawGenBook__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  char *arg2 = 0 ;
  char *arg3 = 0 ;
  sword::SWDisplay *arg4 = 0 ;
  char arg5 ;
  char arg6 ;
  char arg7 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  char val5 ;
  int ecode5 = 0 ;
  char val6 ;
  int ecode6 = 0 ;
  char val7 ;
  int ecode7 = 0 ;
  sword::RawGenBook *result = 0 ;
  
  (void)self;
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_RawGenBook" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_RawGenBook" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_RawGenBook" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_sword__SWDisplay, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_RawGenBook" "', argument " "4"" of type '" "sword::SWDisplay *""'"); 
  }
  arg4 = reinterpret_cast< sword::SWDisplay * >(argp4);
  ecode5 = SWIG_AsVal_char(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_RawGenBook" "', argument " "5"" of type '" "char""'");
  } 
  arg5 = static_cast< char >(val5);
  ecode6 = SWIG_AsVal_char(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_RawGenBook" "', argument " "6"" of type '" "char""'");
  } 
  arg6 = static_cast< char >(val6);
  ecode7 = SWIG_AsVal_char(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_RawGenBook" "', argument " "7"" of type '" "char""'");
  } 
  arg7 = static_cast< char >(val7);
  {
    try {
      result = (sword::RawGenBook *)new sword::RawGenBook((char const *)arg1,(char const *)arg2,(char const *)arg3,arg4,arg5,arg6,arg7); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__RawGenBook, SWIG_POINTER_NEW |  0 );
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RawGenBook__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  char *arg2 = 0 ;
  char *arg3 = 0 ;
  sword::SWDisplay *arg4 = 0 ;
  char arg5 ;
  char arg6 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  char val5 ;
  int ecode5 = 0 ;
  char val6 ;
  int ecode6 = 0 ;
  sword::RawGenBook *result = 0 ;
  
  (void)self;
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_RawGenBook" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_RawGenBook" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_RawGenBook" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_sword__SWDisplay, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_RawGenBook" "', argument " "4"" of type '" "sword::SWDisplay *""'"); 
  }
  arg4 = reinterpret_cast< sword::SWDisplay * >(argp4);
  ecode5 = SWIG_AsVal_char(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_RawGenBook" "', argument " "5"" of type '" "char""'");
  } 
  arg5 = static_cast< char >(val5);
  ecode6 = SWIG_AsVal_char(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_RawGenBook" "', argument " "6"" of type '" "char""'");
  } 
  arg6 = static_cast< char >(val6);
  {
    try {
      result = (sword::RawGenBook *)new sword::RawGenBook((char const *)arg1,(char const *)arg2,(char const *)arg3,arg4,arg5,arg6); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__RawGenBook, SWIG_POINTER_NEW |  0 );
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RawGenBook__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  char *arg2 = 0 ;
  char *arg3 = 0 ;
  sword::SWDisplay *arg4 = 0 ;
  char arg5 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  char val5 ;
  int ecode5 = 0 ;
  sword::RawGenBook *result = 0 ;
  
  (void)self;
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_RawGenBook" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_RawGenBook" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_RawGenBook" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_sword__SWDisplay, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_RawGenBook" "', argument " "4"" of type '" "sword::SWDisplay *""'"); 
  }
  arg4 = reinterpret_cast< sword::SWDisplay * >(argp4);
  ecode5 = SWIG_AsVal_char(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_RawGenBook" "', argument " "5"" of type '" "char""'");
  } 
  arg5 = static_cast< char >(val5);
  {
    try {
      result = (sword::RawGenBook *)new sword::RawGenBook((char const *)arg1,(char const *)arg2,(char const *)arg3,arg4,arg5); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__RawGenBook, SWIG_POINTER_NEW |  0 );
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RawGenBook__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  char *arg2 = 0 ;
  char *arg3 = 0 ;
  sword::SWDisplay *arg4 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  sword::RawGenBook *result = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_RawGenBook" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_RawGenBook" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_RawGenBook" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_sword__SWDisplay, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_RawGenBook" "', argument " "4"" of type '" "sword::SWDisplay *""'"); 
  }
  arg4 = reinterpret_cast< sword::SWDisplay * >(argp4);
  {
    try {
      result = (sword::RawGenBook *)new sword::RawGenBook((char const *)arg1,(char const *)arg2,(char const *)arg3,arg4); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__RawGenBook, SWIG_POINTER_NEW |  0 );
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RawGenBook__SWIG_6(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  char *arg2 = 0 ;
  char *arg3 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  sword::RawGenBook *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_RawGenBook" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_RawGenBook" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_RawGenBook" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  {
    try {
      result = (sword::RawGenBook *)new sword::RawGenBook((char const *)arg1,(char const *)arg2,(char const *)arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__RawGenBook, SWIG_POINTER_NEW |  0 );
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RawGenBook__SWIG_7(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  char *arg2 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  sword::RawGenBook *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_RawGenBook" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_RawGenBook" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    try {
      result = (sword::RawGenBook *)new sword::RawGenBook((char const *)arg1,(char const *)arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__RawGenBook, SWIG_POINTER_NEW |  0 );
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RawGenBook__SWIG_8(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  sword::RawGenBook *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_RawGenBook" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  {
    try {
      result = (sword::RawGenBook *)new sword::RawGenBook((char const *)arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__RawGenBook, SWIG_POINTER_NEW |  0 );
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RawGenBook(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[10] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_RawGenBook", 0, 9, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_RawGenBook__SWIG_8(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_RawGenBook__SWIG_7(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_new_RawGenBook__SWIG_6(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_sword__SWDisplay, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_new_RawGenBook__SWIG_5(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_sword__SWDisplay, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_char(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_new_RawGenBook__SWIG_4(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_sword__SWDisplay, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_char(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_char(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_new_RawGenBook__SWIG_3(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v = 0;
    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_sword__SWDisplay, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_char(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_char(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_char(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_new_RawGenBook__SWIG_2(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v = 0;
    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_sword__SWDisplay, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_char(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_char(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_char(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  int res = SWIG_AsCharPtrAndSize(argv[7], 0, NULL, 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    return _wrap_new_RawGenBook__SWIG_1(self, argc, argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v = 0;
    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_sword__SWDisplay, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_char(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_char(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_char(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  int res = SWIG_AsCharPtrAndSize(argv[7], 0, NULL, 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    int res = SWIG_AsCharPtrAndSize(argv[8], 0, NULL, 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      return _wrap_new_RawGenBook__SWIG_0(self, argc, argv);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_RawGenBook'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    sword::RawGenBook::RawGenBook(char const *,char const *,char const *,sword::SWDisplay *,char,char,char,char const *,char const *)\n"
    "    sword::RawGenBook::RawGenBook(char const *,char const *,char const *,sword::SWDisplay *,char,char,char,char const *)\n"
    "    sword::RawGenBook::RawGenBook(char const *,char const *,char const *,sword::SWDisplay *,char,char,char)\n"
    "    sword::RawGenBook::RawGenBook(char const *,char const *,char const *,sword::SWDisplay *,char,char)\n"
    "    sword::RawGenBook::RawGenBook(char const *,char const *,char const *,sword::SWDisplay *,char)\n"
    "    sword::RawGenBook::RawGenBook(char const *,char const *,char const *,sword::SWDisplay *)\n"
    "    sword::RawGenBook::RawGenBook(char const *,char const *,char const *)\n"
    "    sword::RawGenBook::RawGenBook(char const *,char const *)\n"
    "    sword::RawGenBook::RawGenBook(char const *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_RawGenBook(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::RawGenBook *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__RawGenBook, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RawGenBook" "', argument " "1"" of type '" "sword::RawGenBook *""'"); 
  }
  arg1 = reinterpret_cast< sword::RawGenBook * >(argp1);
  {
    try {
      delete arg1; 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RawGenBook_getRawEntryBuf(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::RawGenBook *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  sword::SWBuf *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__RawGenBook, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RawGenBook_getRawEntryBuf" "', argument " "1"" of type '" "sword::RawGenBook const *""'"); 
  }
  arg1 = reinterpret_cast< sword::RawGenBook * >(argp1);
  {
    try {
      result = (sword::SWBuf *) &((sword::RawGenBook const *)arg1)->getRawEntryBuf(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__SWBuf, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RawGenBook_isWritable(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::RawGenBook *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__RawGenBook, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RawGenBook_isWritable" "', argument " "1"" of type '" "sword::RawGenBook const *""'"); 
  }
  arg1 = reinterpret_cast< sword::RawGenBook * >(argp1);
  {
    try {
      result = (bool)((sword::RawGenBook const *)arg1)->isWritable(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RawGenBook_createModule(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  PyObject *swig_obj[1] ;
  char result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RawGenBook_createModule" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  {
    try {
      result = (char)sword::RawGenBook::createModule((char const *)arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_char(static_cast< char >(result));
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_RawGenBook_setEntry__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::RawGenBook *arg1 = 0 ;
  char *arg2 = 0 ;
  long arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  long val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__RawGenBook, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RawGenBook_setEntry" "', argument " "1"" of type '" "sword::RawGenBook *""'"); 
  }
  arg1 = reinterpret_cast< sword::RawGenBook * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RawGenBook_setEntry" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  ecode3 = SWIG_AsVal_long(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RawGenBook_setEntry" "', argument " "3"" of type '" "long""'");
  } 
  arg3 = static_cast< long >(val3);
  {
    try {
      (arg1)->setEntry((char const *)arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_RawGenBook_setEntry__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::RawGenBook *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__RawGenBook, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RawGenBook_setEntry" "', argument " "1"" of type '" "sword::RawGenBook *""'"); 
  }
  arg1 = reinterpret_cast< sword::RawGenBook * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RawGenBook_setEntry" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    try {
      (arg1)->setEntry((char const *)arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_RawGenBook_setEntry(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "RawGenBook_setEntry", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__RawGenBook, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_RawGenBook_setEntry__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__RawGenBook, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_long(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_RawGenBook_setEntry__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'RawGenBook_setEntry'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    sword::RawGenBook::setEntry(char const *,long)\n"
    "    sword::RawGenBook::setEntry(char const *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_RawGenBook_linkEntry(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::RawGenBook *arg1 = 0 ;
  sword::SWKey *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "RawGenBook_linkEntry", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__RawGenBook, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RawGenBook_linkEntry" "', argument " "1"" of type '" "sword::RawGenBook *""'"); 
  }
  arg1 = reinterpret_cast< sword::RawGenBook * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_sword__SWKey, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RawGenBook_linkEntry" "', argument " "2"" of type '" "sword::SWKey const *""'"); 
  }
  arg2 = reinterpret_cast< sword::SWKey * >(argp2);
  {
    try {
      (arg1)->linkEntry((sword::SWKey const *)arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RawGenBook_deleteEntry(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::RawGenBook *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__RawGenBook, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RawGenBook_deleteEntry" "', argument " "1"" of type '" "sword::RawGenBook *""'"); 
  }
  arg1 = reinterpret_cast< sword::RawGenBook * >(argp1);
  {
    try {
      (arg1)->deleteEntry(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RawGenBook_createKey(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::RawGenBook *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  sword::SWKey *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__RawGenBook, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RawGenBook_createKey" "', argument " "1"" of type '" "sword::RawGenBook const *""'"); 
  }
  arg1 = reinterpret_cast< sword::RawGenBook * >(argp1);
  {
    try {
      result = (sword::SWKey *)((sword::RawGenBook const *)arg1)->createKey(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__SWKey, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RawGenBook_hasEntry(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::RawGenBook *arg1 = 0 ;
  sword::SWKey *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "RawGenBook_hasEntry", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__RawGenBook, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RawGenBook_hasEntry" "', argument " "1"" of type '" "sword::RawGenBook const *""'"); 
  }
  arg1 = reinterpret_cast< sword::RawGenBook * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_sword__SWKey, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RawGenBook_hasEntry" "', argument " "2"" of type '" "sword::SWKey const *""'"); 
  }
  arg2 = reinterpret_cast< sword::SWKey * >(argp2);
  {
    try {
      result = (bool)((sword::RawGenBook const *)arg1)->hasEntry((sword::SWKey const *)arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RawGenBook___lshift____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::RawGenBook *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  sword::SWModule *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__RawGenBook, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RawGenBook___lshift__" "', argument " "1"" of type '" "sword::RawGenBook *""'"); 
  }
  arg1 = reinterpret_cast< sword::RawGenBook * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RawGenBook___lshift__" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    try {
      result = (sword::SWModule *) &(arg1)->operator <<((char const *)arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__SWModule, 0 |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_RawGenBook___lshift____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::RawGenBook *arg1 = 0 ;
  sword::SWKey *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  sword::SWModule *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__RawGenBook, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RawGenBook___lshift__" "', argument " "1"" of type '" "sword::RawGenBook *""'"); 
  }
  arg1 = reinterpret_cast< sword::RawGenBook * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_sword__SWKey, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RawGenBook___lshift__" "', argument " "2"" of type '" "sword::SWKey const *""'"); 
  }
  arg2 = reinterpret_cast< sword::SWKey * >(argp2);
  {
    try {
      result = (sword::SWModule *) &(arg1)->operator <<((sword::SWKey const *)arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__SWModule, 0 |  0 );
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_RawGenBook___lshift__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "RawGenBook___lshift__", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__RawGenBook, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_sword__SWKey, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_RawGenBook___lshift____SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__RawGenBook, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_RawGenBook___lshift____SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_RawGenBook___isub__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::RawGenBook *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  sword::SWModule *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "RawGenBook___isub__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__RawGenBook, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RawGenBook___isub__" "', argument " "1"" of type '" "sword::RawGenBook *""'"); 
  }
  arg1 = reinterpret_cast< sword::RawGenBook * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RawGenBook___isub__" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    try {
      result = (sword::SWModule *) &(arg1)->operator -=(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__SWModule, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RawGenBook___iadd__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::RawGenBook *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  sword::SWModule *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "RawGenBook___iadd__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__RawGenBook, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RawGenBook___iadd__" "', argument " "1"" of type '" "sword::RawGenBook *""'"); 
  }
  arg1 = reinterpret_cast< sword::RawGenBook * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RawGenBook___iadd__" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    try {
      result = (sword::SWModule *) &(arg1)->operator +=(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__SWModule, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RawGenBook_castTo(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWModule *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  sword::RawGenBook *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RawGenBook_castTo" "', argument " "1"" of type '" "sword::SWModule *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWModule * >(argp1);
  {
    try {
      result = (sword::RawGenBook *)sword_RawGenBook_castTo(arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__RawGenBook, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *RawGenBook_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_sword__RawGenBook, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *RawGenBook_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_delete_SWLD(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWLD *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWLD, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SWLD" "', argument " "1"" of type '" "sword::SWLD *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWLD * >(argp1);
  {
    try {
      delete arg1; 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWLD_createKey(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWLD *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  sword::SWKey *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWLD, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWLD_createKey" "', argument " "1"" of type '" "sword::SWLD const *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWLD * >(argp1);
  {
    try {
      result = (sword::SWKey *)((sword::SWLD const *)arg1)->createKey(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__SWKey, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWLD_getKeyText(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWLD *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWLD, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWLD_getKeyText" "', argument " "1"" of type '" "sword::SWLD const *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWLD * >(argp1);
  {
    try {
      result = (char *)((sword::SWLD const *)arg1)->getKeyText(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWLD_setPosition(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWLD *arg1 = 0 ;
  SwigValueWrapper< sword::SW_POSITION > arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SWLD_setPosition", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWLD, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWLD_setPosition" "', argument " "1"" of type '" "sword::SWLD *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWLD * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_sword__SW_POSITION,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SWLD_setPosition" "', argument " "2"" of type '" "sword::SW_POSITION""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SWLD_setPosition" "', argument " "2"" of type '" "sword::SW_POSITION""'");
    } else {
      sword::SW_POSITION * temp = reinterpret_cast< sword::SW_POSITION * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    try {
      (arg1)->setPosition(SWIG_STD_MOVE(arg2)); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWLD_getEntryCount(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWLD *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  long result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWLD, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWLD_getEntryCount" "', argument " "1"" of type '" "sword::SWLD const *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWLD * >(argp1);
  {
    try {
      result = (long)((sword::SWLD const *)arg1)->getEntryCount(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_long(static_cast< long >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWLD_getEntryForKey(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWLD *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  long result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SWLD_getEntryForKey", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWLD, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWLD_getEntryForKey" "', argument " "1"" of type '" "sword::SWLD const *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWLD * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SWLD_getEntryForKey" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    try {
      result = (long)((sword::SWLD const *)arg1)->getEntryForKey((char const *)arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_long(static_cast< long >(result));
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWLD_getKeyForEntry(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWLD *arg1 = 0 ;
  long arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  long val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  char *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SWLD_getKeyForEntry", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWLD, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWLD_getKeyForEntry" "', argument " "1"" of type '" "sword::SWLD const *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWLD * >(argp1);
  ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SWLD_getKeyForEntry" "', argument " "2"" of type '" "long""'");
  } 
  arg2 = static_cast< long >(val2);
  {
    try {
      result = (char *)((sword::SWLD const *)arg1)->getKeyForEntry(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWLD_hasEntry(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWLD *arg1 = 0 ;
  sword::SWKey *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SWLD_hasEntry", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWLD, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWLD_hasEntry" "', argument " "1"" of type '" "sword::SWLD const *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWLD * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_sword__SWKey, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SWLD_hasEntry" "', argument " "2"" of type '" "sword::SWKey const *""'"); 
  }
  arg2 = reinterpret_cast< sword::SWKey * >(argp2);
  {
    try {
      result = (bool)((sword::SWLD const *)arg1)->hasEntry((sword::SWKey const *)arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWLD___lshift____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::SWLD *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  sword::SWModule *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWLD, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWLD___lshift__" "', argument " "1"" of type '" "sword::SWLD *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWLD * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SWLD___lshift__" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    try {
      result = (sword::SWModule *) &(arg1)->operator <<((char const *)arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__SWModule, 0 |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SWLD___lshift____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::SWLD *arg1 = 0 ;
  sword::SWKey *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  sword::SWModule *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWLD, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWLD___lshift__" "', argument " "1"" of type '" "sword::SWLD *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWLD * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_sword__SWKey, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SWLD___lshift__" "', argument " "2"" of type '" "sword::SWKey const *""'"); 
  }
  arg2 = reinterpret_cast< sword::SWKey * >(argp2);
  {
    try {
      result = (sword::SWModule *) &(arg1)->operator <<((sword::SWKey const *)arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__SWModule, 0 |  0 );
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SWLD___lshift__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SWLD___lshift__", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__SWLD, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_sword__SWKey, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SWLD___lshift____SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__SWLD, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SWLD___lshift____SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SWLD___isub__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWLD *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  sword::SWModule *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SWLD___isub__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWLD, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWLD___isub__" "', argument " "1"" of type '" "sword::SWLD *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWLD * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SWLD___isub__" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    try {
      result = (sword::SWModule *) &(arg1)->operator -=(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__SWModule, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWLD___iadd__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWLD *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  sword::SWModule *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SWLD___iadd__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWLD, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWLD___iadd__" "', argument " "1"" of type '" "sword::SWLD *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWLD * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SWLD___iadd__" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    try {
      result = (sword::SWModule *) &(arg1)->operator +=(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__SWModule, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWLD_castTo(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWModule *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  sword::SWLD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWLD_castTo" "', argument " "1"" of type '" "sword::SWModule *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWModule * >(argp1);
  {
    try {
      result = (sword::SWLD *)sword_SWLD_castTo(arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__SWLD, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SWLD_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_sword__SWLD, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_RawLD__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  char *arg2 = 0 ;
  char *arg3 = 0 ;
  sword::SWDisplay *arg4 = 0 ;
  char arg5 ;
  char arg6 ;
  char arg7 ;
  char *arg8 = 0 ;
  bool arg9 ;
  bool arg10 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  char val5 ;
  int ecode5 = 0 ;
  char val6 ;
  int ecode6 = 0 ;
  char val7 ;
  int ecode7 = 0 ;
  int res8 ;
  char *buf8 = 0 ;
  int alloc8 = 0 ;
  bool val9 ;
  int ecode9 = 0 ;
  bool val10 ;
  int ecode10 = 0 ;
  sword::RawLD *result = 0 ;
  
  (void)self;
  if ((nobjs < 10) || (nobjs > 10)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_RawLD" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_RawLD" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_RawLD" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_sword__SWDisplay, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_RawLD" "', argument " "4"" of type '" "sword::SWDisplay *""'"); 
  }
  arg4 = reinterpret_cast< sword::SWDisplay * >(argp4);
  ecode5 = SWIG_AsVal_char(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_RawLD" "', argument " "5"" of type '" "char""'");
  } 
  arg5 = static_cast< char >(val5);
  ecode6 = SWIG_AsVal_char(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_RawLD" "', argument " "6"" of type '" "char""'");
  } 
  arg6 = static_cast< char >(val6);
  ecode7 = SWIG_AsVal_char(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_RawLD" "', argument " "7"" of type '" "char""'");
  } 
  arg7 = static_cast< char >(val7);
  res8 = SWIG_AsCharPtrAndSize(swig_obj[7], &buf8, NULL, &alloc8);
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "new_RawLD" "', argument " "8"" of type '" "char const *""'");
  }
  arg8 = reinterpret_cast< char * >(buf8);
  ecode9 = SWIG_AsVal_bool(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_RawLD" "', argument " "9"" of type '" "bool""'");
  } 
  arg9 = static_cast< bool >(val9);
  ecode10 = SWIG_AsVal_bool(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_RawLD" "', argument " "10"" of type '" "bool""'");
  } 
  arg10 = static_cast< bool >(val10);
  {
    try {
      result = (sword::RawLD *)new sword::RawLD((char const *)arg1,(char const *)arg2,(char const *)arg3,arg4,arg5,arg6,arg7,(char const *)arg8,arg9,arg10); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__RawLD, SWIG_POINTER_NEW |  0 );
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  if (alloc8 == SWIG_NEWOBJ) delete[] buf8;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  if (alloc8 == SWIG_NEWOBJ) delete[] buf8;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RawLD__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  char *arg2 = 0 ;
  char *arg3 = 0 ;
  sword::SWDisplay *arg4 = 0 ;
  char arg5 ;
  char arg6 ;
  char arg7 ;
  char *arg8 = 0 ;
  bool arg9 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  char val5 ;
  int ecode5 = 0 ;
  char val6 ;
  int ecode6 = 0 ;
  char val7 ;
  int ecode7 = 0 ;
  int res8 ;
  char *buf8 = 0 ;
  int alloc8 = 0 ;
  bool val9 ;
  int ecode9 = 0 ;
  sword::RawLD *result = 0 ;
  
  (void)self;
  if ((nobjs < 9) || (nobjs > 9)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_RawLD" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_RawLD" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_RawLD" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_sword__SWDisplay, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_RawLD" "', argument " "4"" of type '" "sword::SWDisplay *""'"); 
  }
  arg4 = reinterpret_cast< sword::SWDisplay * >(argp4);
  ecode5 = SWIG_AsVal_char(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_RawLD" "', argument " "5"" of type '" "char""'");
  } 
  arg5 = static_cast< char >(val5);
  ecode6 = SWIG_AsVal_char(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_RawLD" "', argument " "6"" of type '" "char""'");
  } 
  arg6 = static_cast< char >(val6);
  ecode7 = SWIG_AsVal_char(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_RawLD" "', argument " "7"" of type '" "char""'");
  } 
  arg7 = static_cast< char >(val7);
  res8 = SWIG_AsCharPtrAndSize(swig_obj[7], &buf8, NULL, &alloc8);
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "new_RawLD" "', argument " "8"" of type '" "char const *""'");
  }
  arg8 = reinterpret_cast< char * >(buf8);
  ecode9 = SWIG_AsVal_bool(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_RawLD" "', argument " "9"" of type '" "bool""'");
  } 
  arg9 = static_cast< bool >(val9);
  {
    try {
      result = (sword::RawLD *)new sword::RawLD((char const *)arg1,(char const *)arg2,(char const *)arg3,arg4,arg5,arg6,arg7,(char const *)arg8,arg9); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__RawLD, SWIG_POINTER_NEW |  0 );
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  if (alloc8 == SWIG_NEWOBJ) delete[] buf8;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  if (alloc8 == SWIG_NEWOBJ) delete[] buf8;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RawLD__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  char *arg2 = 0 ;
  char *arg3 = 0 ;
  sword::SWDisplay *arg4 = 0 ;
  char arg5 ;
  char arg6 ;
  char arg7 ;
  char *arg8 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  char val5 ;
  int ecode5 = 0 ;
  char val6 ;
  int ecode6 = 0 ;
  char val7 ;
  int ecode7 = 0 ;
  int res8 ;
  char *buf8 = 0 ;
  int alloc8 = 0 ;
  sword::RawLD *result = 0 ;
  
  (void)self;
  if ((nobjs < 8) || (nobjs > 8)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_RawLD" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_RawLD" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_RawLD" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_sword__SWDisplay, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_RawLD" "', argument " "4"" of type '" "sword::SWDisplay *""'"); 
  }
  arg4 = reinterpret_cast< sword::SWDisplay * >(argp4);
  ecode5 = SWIG_AsVal_char(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_RawLD" "', argument " "5"" of type '" "char""'");
  } 
  arg5 = static_cast< char >(val5);
  ecode6 = SWIG_AsVal_char(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_RawLD" "', argument " "6"" of type '" "char""'");
  } 
  arg6 = static_cast< char >(val6);
  ecode7 = SWIG_AsVal_char(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_RawLD" "', argument " "7"" of type '" "char""'");
  } 
  arg7 = static_cast< char >(val7);
  res8 = SWIG_AsCharPtrAndSize(swig_obj[7], &buf8, NULL, &alloc8);
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "new_RawLD" "', argument " "8"" of type '" "char const *""'");
  }
  arg8 = reinterpret_cast< char * >(buf8);
  {
    try {
      result = (sword::RawLD *)new sword::RawLD((char const *)arg1,(char const *)arg2,(char const *)arg3,arg4,arg5,arg6,arg7,(char const *)arg8); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__RawLD, SWIG_POINTER_NEW |  0 );
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  if (alloc8 == SWIG_NEWOBJ) delete[] buf8;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  if (alloc8 == SWIG_NEWOBJ) delete[] buf8;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RawLD__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  char *arg2 = 0 ;
  char *arg3 = 0 ;
  sword::SWDisplay *arg4 = 0 ;
  char arg5 ;
  char arg6 ;
  char arg7 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  char val5 ;
  int ecode5 = 0 ;
  char val6 ;
  int ecode6 = 0 ;
  char val7 ;
  int ecode7 = 0 ;
  sword::RawLD *result = 0 ;
  
  (void)self;
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_RawLD" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_RawLD" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_RawLD" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_sword__SWDisplay, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_RawLD" "', argument " "4"" of type '" "sword::SWDisplay *""'"); 
  }
  arg4 = reinterpret_cast< sword::SWDisplay * >(argp4);
  ecode5 = SWIG_AsVal_char(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_RawLD" "', argument " "5"" of type '" "char""'");
  } 
  arg5 = static_cast< char >(val5);
  ecode6 = SWIG_AsVal_char(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_RawLD" "', argument " "6"" of type '" "char""'");
  } 
  arg6 = static_cast< char >(val6);
  ecode7 = SWIG_AsVal_char(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_RawLD" "', argument " "7"" of type '" "char""'");
  } 
  arg7 = static_cast< char >(val7);
  {
    try {
      result = (sword::RawLD *)new sword::RawLD((char const *)arg1,(char const *)arg2,(char const *)arg3,arg4,arg5,arg6,arg7); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__RawLD, SWIG_POINTER_NEW |  0 );
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RawLD__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  char *arg2 = 0 ;
  char *arg3 = 0 ;
  sword::SWDisplay *arg4 = 0 ;
  char arg5 ;
  char arg6 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  char val5 ;
  int ecode5 = 0 ;
  char val6 ;
  int ecode6 = 0 ;
  sword::RawLD *result = 0 ;
  
  (void)self;
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_RawLD" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_RawLD" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_RawLD" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_sword__SWDisplay, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_RawLD" "', argument " "4"" of type '" "sword::SWDisplay *""'"); 
  }
  arg4 = reinterpret_cast< sword::SWDisplay * >(argp4);
  ecode5 = SWIG_AsVal_char(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_RawLD" "', argument " "5"" of type '" "char""'");
  } 
  arg5 = static_cast< char >(val5);
  ecode6 = SWIG_AsVal_char(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_RawLD" "', argument " "6"" of type '" "char""'");
  } 
  arg6 = static_cast< char >(val6);
  {
    try {
      result = (sword::RawLD *)new sword::RawLD((char const *)arg1,(char const *)arg2,(char const *)arg3,arg4,arg5,arg6); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__RawLD, SWIG_POINTER_NEW |  0 );
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RawLD__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  char *arg2 = 0 ;
  char *arg3 = 0 ;
  sword::SWDisplay *arg4 = 0 ;
  char arg5 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  char val5 ;
  int ecode5 = 0 ;
  sword::RawLD *result = 0 ;
  
  (void)self;
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_RawLD" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_RawLD" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_RawLD" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_sword__SWDisplay, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_RawLD" "', argument " "4"" of type '" "sword::SWDisplay *""'"); 
  }
  arg4 = reinterpret_cast< sword::SWDisplay * >(argp4);
  ecode5 = SWIG_AsVal_char(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_RawLD" "', argument " "5"" of type '" "char""'");
  } 
  arg5 = static_cast< char >(val5);
  {
    try {
      result = (sword::RawLD *)new sword::RawLD((char const *)arg1,(char const *)arg2,(char const *)arg3,arg4,arg5); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__RawLD, SWIG_POINTER_NEW |  0 );
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RawLD__SWIG_6(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  char *arg2 = 0 ;
  char *arg3 = 0 ;
  sword::SWDisplay *arg4 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  sword::RawLD *result = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_RawLD" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_RawLD" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_RawLD" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_sword__SWDisplay, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_RawLD" "', argument " "4"" of type '" "sword::SWDisplay *""'"); 
  }
  arg4 = reinterpret_cast< sword::SWDisplay * >(argp4);
  {
    try {
      result = (sword::RawLD *)new sword::RawLD((char const *)arg1,(char const *)arg2,(char const *)arg3,arg4); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__RawLD, SWIG_POINTER_NEW |  0 );
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RawLD__SWIG_7(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  char *arg2 = 0 ;
  char *arg3 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  sword::RawLD *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_RawLD" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_RawLD" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_RawLD" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  {
    try {
      result = (sword::RawLD *)new sword::RawLD((char const *)arg1,(char const *)arg2,(char const *)arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__RawLD, SWIG_POINTER_NEW |  0 );
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RawLD__SWIG_8(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  char *arg2 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  sword::RawLD *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_RawLD" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_RawLD" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    try {
      result = (sword::RawLD *)new sword::RawLD((char const *)arg1,(char const *)arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__RawLD, SWIG_POINTER_NEW |  0 );
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RawLD__SWIG_9(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  sword::RawLD *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_RawLD" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  {
    try {
      result = (sword::RawLD *)new sword::RawLD((char const *)arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__RawLD, SWIG_POINTER_NEW |  0 );
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RawLD(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[11] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_RawLD", 0, 10, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_RawLD__SWIG_9(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_RawLD__SWIG_8(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_new_RawLD__SWIG_7(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_sword__SWDisplay, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_new_RawLD__SWIG_6(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_sword__SWDisplay, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_char(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_new_RawLD__SWIG_5(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_sword__SWDisplay, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_char(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_char(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_new_RawLD__SWIG_4(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v = 0;
    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_sword__SWDisplay, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_char(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_char(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_char(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_new_RawLD__SWIG_3(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v = 0;
    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_sword__SWDisplay, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_char(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_char(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_char(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  int res = SWIG_AsCharPtrAndSize(argv[7], 0, NULL, 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    return _wrap_new_RawLD__SWIG_2(self, argc, argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v = 0;
    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_sword__SWDisplay, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_char(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_char(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_char(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  int res = SWIG_AsCharPtrAndSize(argv[7], 0, NULL, 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    {
                      int res = SWIG_AsVal_bool(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      return _wrap_new_RawLD__SWIG_1(self, argc, argv);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 10) {
    int _v = 0;
    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_sword__SWDisplay, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_char(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_char(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_char(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  int res = SWIG_AsCharPtrAndSize(argv[7], 0, NULL, 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    {
                      int res = SWIG_AsVal_bool(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_bool(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        return _wrap_new_RawLD__SWIG_0(self, argc, argv);
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_RawLD'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    sword::RawLD::RawLD(char const *,char const *,char const *,sword::SWDisplay *,char,char,char,char const *,bool,bool)\n"
    "    sword::RawLD::RawLD(char const *,char const *,char const *,sword::SWDisplay *,char,char,char,char const *,bool)\n"
    "    sword::RawLD::RawLD(char const *,char const *,char const *,sword::SWDisplay *,char,char,char,char const *)\n"
    "    sword::RawLD::RawLD(char const *,char const *,char const *,sword::SWDisplay *,char,char,char)\n"
    "    sword::RawLD::RawLD(char const *,char const *,char const *,sword::SWDisplay *,char,char)\n"
    "    sword::RawLD::RawLD(char const *,char const *,char const *,sword::SWDisplay *,char)\n"
    "    sword::RawLD::RawLD(char const *,char const *,char const *,sword::SWDisplay *)\n"
    "    sword::RawLD::RawLD(char const *,char const *,char const *)\n"
    "    sword::RawLD::RawLD(char const *,char const *)\n"
    "    sword::RawLD::RawLD(char const *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_RawLD(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::RawLD *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__RawLD, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RawLD" "', argument " "1"" of type '" "sword::RawLD *""'"); 
  }
  arg1 = reinterpret_cast< sword::RawLD * >(argp1);
  {
    try {
      delete arg1; 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RawLD_getRawEntryBuf(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::RawLD *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  sword::SWBuf *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__RawLD, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RawLD_getRawEntryBuf" "', argument " "1"" of type '" "sword::RawLD const *""'"); 
  }
  arg1 = reinterpret_cast< sword::RawLD * >(argp1);
  {
    try {
      result = (sword::SWBuf *) &((sword::RawLD const *)arg1)->getRawEntryBuf(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__SWBuf, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RawLD_increment__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::RawLD *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__RawLD, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RawLD_increment" "', argument " "1"" of type '" "sword::RawLD *""'"); 
  }
  arg1 = reinterpret_cast< sword::RawLD * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RawLD_increment" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    try {
      (arg1)->increment(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RawLD_increment__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::RawLD *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__RawLD, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RawLD_increment" "', argument " "1"" of type '" "sword::RawLD *""'"); 
  }
  arg1 = reinterpret_cast< sword::RawLD * >(argp1);
  {
    try {
      (arg1)->increment(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RawLD_increment(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "RawLD_increment", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__RawLD, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_RawLD_increment__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__RawLD, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_RawLD_increment__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'RawLD_increment'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    sword::RawLD::increment(int)\n"
    "    sword::RawLD::increment()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_RawLD_decrement__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::RawLD *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__RawLD, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RawLD_decrement" "', argument " "1"" of type '" "sword::RawLD *""'"); 
  }
  arg1 = reinterpret_cast< sword::RawLD * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RawLD_decrement" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    try {
      (arg1)->decrement(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RawLD_decrement__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::RawLD *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__RawLD, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RawLD_decrement" "', argument " "1"" of type '" "sword::RawLD *""'"); 
  }
  arg1 = reinterpret_cast< sword::RawLD * >(argp1);
  {
    try {
      (arg1)->decrement(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RawLD_decrement(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "RawLD_decrement", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__RawLD, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_RawLD_decrement__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__RawLD, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_RawLD_decrement__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'RawLD_decrement'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    sword::RawLD::decrement(int)\n"
    "    sword::RawLD::decrement()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_RawLD_isWritable(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::RawLD *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__RawLD, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RawLD_isWritable" "', argument " "1"" of type '" "sword::RawLD const *""'"); 
  }
  arg1 = reinterpret_cast< sword::RawLD * >(argp1);
  {
    try {
      result = (bool)((sword::RawLD const *)arg1)->isWritable(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RawLD_createModule(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  PyObject *swig_obj[1] ;
  char result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RawLD_createModule" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  {
    try {
      result = (char)sword::RawLD::createModule((char const *)arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_char(static_cast< char >(result));
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_RawLD_setEntry__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::RawLD *arg1 = 0 ;
  char *arg2 = 0 ;
  long arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  long val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__RawLD, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RawLD_setEntry" "', argument " "1"" of type '" "sword::RawLD *""'"); 
  }
  arg1 = reinterpret_cast< sword::RawLD * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RawLD_setEntry" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  ecode3 = SWIG_AsVal_long(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RawLD_setEntry" "', argument " "3"" of type '" "long""'");
  } 
  arg3 = static_cast< long >(val3);
  {
    try {
      (arg1)->setEntry((char const *)arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_RawLD_setEntry__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::RawLD *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__RawLD, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RawLD_setEntry" "', argument " "1"" of type '" "sword::RawLD *""'"); 
  }
  arg1 = reinterpret_cast< sword::RawLD * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RawLD_setEntry" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    try {
      (arg1)->setEntry((char const *)arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_RawLD_setEntry(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "RawLD_setEntry", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__RawLD, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_RawLD_setEntry__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__RawLD, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_long(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_RawLD_setEntry__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'RawLD_setEntry'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    sword::RawLD::setEntry(char const *,long)\n"
    "    sword::RawLD::setEntry(char const *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_RawLD_linkEntry(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::RawLD *arg1 = 0 ;
  sword::SWKey *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "RawLD_linkEntry", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__RawLD, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RawLD_linkEntry" "', argument " "1"" of type '" "sword::RawLD *""'"); 
  }
  arg1 = reinterpret_cast< sword::RawLD * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_sword__SWKey, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RawLD_linkEntry" "', argument " "2"" of type '" "sword::SWKey const *""'"); 
  }
  arg2 = reinterpret_cast< sword::SWKey * >(argp2);
  {
    try {
      (arg1)->linkEntry((sword::SWKey const *)arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RawLD_deleteEntry(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::RawLD *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__RawLD, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RawLD_deleteEntry" "', argument " "1"" of type '" "sword::RawLD *""'"); 
  }
  arg1 = reinterpret_cast< sword::RawLD * >(argp1);
  {
    try {
      (arg1)->deleteEntry(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RawLD_getEntryCount(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::RawLD *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  long result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__RawLD, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RawLD_getEntryCount" "', argument " "1"" of type '" "sword::RawLD const *""'"); 
  }
  arg1 = reinterpret_cast< sword::RawLD * >(argp1);
  {
    try {
      result = (long)((sword::RawLD const *)arg1)->getEntryCount(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_long(static_cast< long >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RawLD_getEntryForKey(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::RawLD *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  long result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "RawLD_getEntryForKey", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__RawLD, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RawLD_getEntryForKey" "', argument " "1"" of type '" "sword::RawLD const *""'"); 
  }
  arg1 = reinterpret_cast< sword::RawLD * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RawLD_getEntryForKey" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    try {
      result = (long)((sword::RawLD const *)arg1)->getEntryForKey((char const *)arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_long(static_cast< long >(result));
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_RawLD_getKeyForEntry(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::RawLD *arg1 = 0 ;
  long arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  long val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  char *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "RawLD_getKeyForEntry", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__RawLD, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RawLD_getKeyForEntry" "', argument " "1"" of type '" "sword::RawLD const *""'"); 
  }
  arg1 = reinterpret_cast< sword::RawLD * >(argp1);
  ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RawLD_getKeyForEntry" "', argument " "2"" of type '" "long""'");
  } 
  arg2 = static_cast< long >(val2);
  {
    try {
      result = (char *)((sword::RawLD const *)arg1)->getKeyForEntry(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RawLD___lshift____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::RawLD *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  sword::SWModule *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__RawLD, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RawLD___lshift__" "', argument " "1"" of type '" "sword::RawLD *""'"); 
  }
  arg1 = reinterpret_cast< sword::RawLD * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RawLD___lshift__" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    try {
      result = (sword::SWModule *) &(arg1)->operator <<((char const *)arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__SWModule, 0 |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_RawLD___lshift____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::RawLD *arg1 = 0 ;
  sword::SWKey *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  sword::SWModule *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__RawLD, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RawLD___lshift__" "', argument " "1"" of type '" "sword::RawLD *""'"); 
  }
  arg1 = reinterpret_cast< sword::RawLD * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_sword__SWKey, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RawLD___lshift__" "', argument " "2"" of type '" "sword::SWKey const *""'"); 
  }
  arg2 = reinterpret_cast< sword::SWKey * >(argp2);
  {
    try {
      result = (sword::SWModule *) &(arg1)->operator <<((sword::SWKey const *)arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__SWModule, 0 |  0 );
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_RawLD___lshift__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "RawLD___lshift__", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__RawLD, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_sword__SWKey, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_RawLD___lshift____SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__RawLD, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_RawLD___lshift____SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_RawLD___isub__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::RawLD *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  sword::SWModule *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "RawLD___isub__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__RawLD, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RawLD___isub__" "', argument " "1"" of type '" "sword::RawLD *""'"); 
  }
  arg1 = reinterpret_cast< sword::RawLD * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RawLD___isub__" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    try {
      result = (sword::SWModule *) &(arg1)->operator -=(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__SWModule, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RawLD___iadd__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::RawLD *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  sword::SWModule *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "RawLD___iadd__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__RawLD, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RawLD___iadd__" "', argument " "1"" of type '" "sword::RawLD *""'"); 
  }
  arg1 = reinterpret_cast< sword::RawLD * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RawLD___iadd__" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    try {
      result = (sword::SWModule *) &(arg1)->operator +=(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__SWModule, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RawLD_castTo(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWModule *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  sword::RawLD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RawLD_castTo" "', argument " "1"" of type '" "sword::SWModule *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWModule * >(argp1);
  {
    try {
      result = (sword::RawLD *)sword_RawLD_castTo(arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__RawLD, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *RawLD_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_sword__RawLD, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *RawLD_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_RawLD4__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  char *arg2 = 0 ;
  char *arg3 = 0 ;
  sword::SWDisplay *arg4 = 0 ;
  char arg5 ;
  char arg6 ;
  char arg7 ;
  char *arg8 = 0 ;
  bool arg9 ;
  bool arg10 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  char val5 ;
  int ecode5 = 0 ;
  char val6 ;
  int ecode6 = 0 ;
  char val7 ;
  int ecode7 = 0 ;
  int res8 ;
  char *buf8 = 0 ;
  int alloc8 = 0 ;
  bool val9 ;
  int ecode9 = 0 ;
  bool val10 ;
  int ecode10 = 0 ;
  sword::RawLD4 *result = 0 ;
  
  (void)self;
  if ((nobjs < 10) || (nobjs > 10)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_RawLD4" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_RawLD4" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_RawLD4" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_sword__SWDisplay, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_RawLD4" "', argument " "4"" of type '" "sword::SWDisplay *""'"); 
  }
  arg4 = reinterpret_cast< sword::SWDisplay * >(argp4);
  ecode5 = SWIG_AsVal_char(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_RawLD4" "', argument " "5"" of type '" "char""'");
  } 
  arg5 = static_cast< char >(val5);
  ecode6 = SWIG_AsVal_char(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_RawLD4" "', argument " "6"" of type '" "char""'");
  } 
  arg6 = static_cast< char >(val6);
  ecode7 = SWIG_AsVal_char(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_RawLD4" "', argument " "7"" of type '" "char""'");
  } 
  arg7 = static_cast< char >(val7);
  res8 = SWIG_AsCharPtrAndSize(swig_obj[7], &buf8, NULL, &alloc8);
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "new_RawLD4" "', argument " "8"" of type '" "char const *""'");
  }
  arg8 = reinterpret_cast< char * >(buf8);
  ecode9 = SWIG_AsVal_bool(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_RawLD4" "', argument " "9"" of type '" "bool""'");
  } 
  arg9 = static_cast< bool >(val9);
  ecode10 = SWIG_AsVal_bool(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_RawLD4" "', argument " "10"" of type '" "bool""'");
  } 
  arg10 = static_cast< bool >(val10);
  {
    try {
      result = (sword::RawLD4 *)new sword::RawLD4((char const *)arg1,(char const *)arg2,(char const *)arg3,arg4,arg5,arg6,arg7,(char const *)arg8,arg9,arg10); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__RawLD4, SWIG_POINTER_NEW |  0 );
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  if (alloc8 == SWIG_NEWOBJ) delete[] buf8;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  if (alloc8 == SWIG_NEWOBJ) delete[] buf8;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RawLD4__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  char *arg2 = 0 ;
  char *arg3 = 0 ;
  sword::SWDisplay *arg4 = 0 ;
  char arg5 ;
  char arg6 ;
  char arg7 ;
  char *arg8 = 0 ;
  bool arg9 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  char val5 ;
  int ecode5 = 0 ;
  char val6 ;
  int ecode6 = 0 ;
  char val7 ;
  int ecode7 = 0 ;
  int res8 ;
  char *buf8 = 0 ;
  int alloc8 = 0 ;
  bool val9 ;
  int ecode9 = 0 ;
  sword::RawLD4 *result = 0 ;
  
  (void)self;
  if ((nobjs < 9) || (nobjs > 9)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_RawLD4" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_RawLD4" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_RawLD4" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_sword__SWDisplay, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_RawLD4" "', argument " "4"" of type '" "sword::SWDisplay *""'"); 
  }
  arg4 = reinterpret_cast< sword::SWDisplay * >(argp4);
  ecode5 = SWIG_AsVal_char(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_RawLD4" "', argument " "5"" of type '" "char""'");
  } 
  arg5 = static_cast< char >(val5);
  ecode6 = SWIG_AsVal_char(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_RawLD4" "', argument " "6"" of type '" "char""'");
  } 
  arg6 = static_cast< char >(val6);
  ecode7 = SWIG_AsVal_char(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_RawLD4" "', argument " "7"" of type '" "char""'");
  } 
  arg7 = static_cast< char >(val7);
  res8 = SWIG_AsCharPtrAndSize(swig_obj[7], &buf8, NULL, &alloc8);
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "new_RawLD4" "', argument " "8"" of type '" "char const *""'");
  }
  arg8 = reinterpret_cast< char * >(buf8);
  ecode9 = SWIG_AsVal_bool(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_RawLD4" "', argument " "9"" of type '" "bool""'");
  } 
  arg9 = static_cast< bool >(val9);
  {
    try {
      result = (sword::RawLD4 *)new sword::RawLD4((char const *)arg1,(char const *)arg2,(char const *)arg3,arg4,arg5,arg6,arg7,(char const *)arg8,arg9); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__RawLD4, SWIG_POINTER_NEW |  0 );
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  if (alloc8 == SWIG_NEWOBJ) delete[] buf8;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  if (alloc8 == SWIG_NEWOBJ) delete[] buf8;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RawLD4__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  char *arg2 = 0 ;
  char *arg3 = 0 ;
  sword::SWDisplay *arg4 = 0 ;
  char arg5 ;
  char arg6 ;
  char arg7 ;
  char *arg8 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  char val5 ;
  int ecode5 = 0 ;
  char val6 ;
  int ecode6 = 0 ;
  char val7 ;
  int ecode7 = 0 ;
  int res8 ;
  char *buf8 = 0 ;
  int alloc8 = 0 ;
  sword::RawLD4 *result = 0 ;
  
  (void)self;
  if ((nobjs < 8) || (nobjs > 8)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_RawLD4" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_RawLD4" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_RawLD4" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_sword__SWDisplay, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_RawLD4" "', argument " "4"" of type '" "sword::SWDisplay *""'"); 
  }
  arg4 = reinterpret_cast< sword::SWDisplay * >(argp4);
  ecode5 = SWIG_AsVal_char(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_RawLD4" "', argument " "5"" of type '" "char""'");
  } 
  arg5 = static_cast< char >(val5);
  ecode6 = SWIG_AsVal_char(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_RawLD4" "', argument " "6"" of type '" "char""'");
  } 
  arg6 = static_cast< char >(val6);
  ecode7 = SWIG_AsVal_char(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_RawLD4" "', argument " "7"" of type '" "char""'");
  } 
  arg7 = static_cast< char >(val7);
  res8 = SWIG_AsCharPtrAndSize(swig_obj[7], &buf8, NULL, &alloc8);
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "new_RawLD4" "', argument " "8"" of type '" "char const *""'");
  }
  arg8 = reinterpret_cast< char * >(buf8);
  {
    try {
      result = (sword::RawLD4 *)new sword::RawLD4((char const *)arg1,(char const *)arg2,(char const *)arg3,arg4,arg5,arg6,arg7,(char const *)arg8); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__RawLD4, SWIG_POINTER_NEW |  0 );
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  if (alloc8 == SWIG_NEWOBJ) delete[] buf8;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  if (alloc8 == SWIG_NEWOBJ) delete[] buf8;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RawLD4__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  char *arg2 = 0 ;
  char *arg3 = 0 ;
  sword::SWDisplay *arg4 = 0 ;
  char arg5 ;
  char arg6 ;
  char arg7 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  char val5 ;
  int ecode5 = 0 ;
  char val6 ;
  int ecode6 = 0 ;
  char val7 ;
  int ecode7 = 0 ;
  sword::RawLD4 *result = 0 ;
  
  (void)self;
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_RawLD4" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_RawLD4" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_RawLD4" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_sword__SWDisplay, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_RawLD4" "', argument " "4"" of type '" "sword::SWDisplay *""'"); 
  }
  arg4 = reinterpret_cast< sword::SWDisplay * >(argp4);
  ecode5 = SWIG_AsVal_char(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_RawLD4" "', argument " "5"" of type '" "char""'");
  } 
  arg5 = static_cast< char >(val5);
  ecode6 = SWIG_AsVal_char(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_RawLD4" "', argument " "6"" of type '" "char""'");
  } 
  arg6 = static_cast< char >(val6);
  ecode7 = SWIG_AsVal_char(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_RawLD4" "', argument " "7"" of type '" "char""'");
  } 
  arg7 = static_cast< char >(val7);
  {
    try {
      result = (sword::RawLD4 *)new sword::RawLD4((char const *)arg1,(char const *)arg2,(char const *)arg3,arg4,arg5,arg6,arg7); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__RawLD4, SWIG_POINTER_NEW |  0 );
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RawLD4__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  char *arg2 = 0 ;
  char *arg3 = 0 ;
  sword::SWDisplay *arg4 = 0 ;
  char arg5 ;
  char arg6 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  char val5 ;
  int ecode5 = 0 ;
  char val6 ;
  int ecode6 = 0 ;
  sword::RawLD4 *result = 0 ;
  
  (void)self;
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_RawLD4" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_RawLD4" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_RawLD4" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_sword__SWDisplay, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_RawLD4" "', argument " "4"" of type '" "sword::SWDisplay *""'"); 
  }
  arg4 = reinterpret_cast< sword::SWDisplay * >(argp4);
  ecode5 = SWIG_AsVal_char(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_RawLD4" "', argument " "5"" of type '" "char""'");
  } 
  arg5 = static_cast< char >(val5);
  ecode6 = SWIG_AsVal_char(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_RawLD4" "', argument " "6"" of type '" "char""'");
  } 
  arg6 = static_cast< char >(val6);
  {
    try {
      result = (sword::RawLD4 *)new sword::RawLD4((char const *)arg1,(char const *)arg2,(char const *)arg3,arg4,arg5,arg6); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__RawLD4, SWIG_POINTER_NEW |  0 );
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RawLD4__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  char *arg2 = 0 ;
  char *arg3 = 0 ;
  sword::SWDisplay *arg4 = 0 ;
  char arg5 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  char val5 ;
  int ecode5 = 0 ;
  sword::RawLD4 *result = 0 ;
  
  (void)self;
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_RawLD4" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_RawLD4" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_RawLD4" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_sword__SWDisplay, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_RawLD4" "', argument " "4"" of type '" "sword::SWDisplay *""'"); 
  }
  arg4 = reinterpret_cast< sword::SWDisplay * >(argp4);
  ecode5 = SWIG_AsVal_char(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_RawLD4" "', argument " "5"" of type '" "char""'");
  } 
  arg5 = static_cast< char >(val5);
  {
    try {
      result = (sword::RawLD4 *)new sword::RawLD4((char const *)arg1,(char const *)arg2,(char const *)arg3,arg4,arg5); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__RawLD4, SWIG_POINTER_NEW |  0 );
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RawLD4__SWIG_6(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  char *arg2 = 0 ;
  char *arg3 = 0 ;
  sword::SWDisplay *arg4 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  sword::RawLD4 *result = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_RawLD4" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_RawLD4" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_RawLD4" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_sword__SWDisplay, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_RawLD4" "', argument " "4"" of type '" "sword::SWDisplay *""'"); 
  }
  arg4 = reinterpret_cast< sword::SWDisplay * >(argp4);
  {
    try {
      result = (sword::RawLD4 *)new sword::RawLD4((char const *)arg1,(char const *)arg2,(char const *)arg3,arg4); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__RawLD4, SWIG_POINTER_NEW |  0 );
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RawLD4__SWIG_7(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  char *arg2 = 0 ;
  char *arg3 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  sword::RawLD4 *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_RawLD4" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_RawLD4" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_RawLD4" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  {
    try {
      result = (sword::RawLD4 *)new sword::RawLD4((char const *)arg1,(char const *)arg2,(char const *)arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__RawLD4, SWIG_POINTER_NEW |  0 );
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RawLD4__SWIG_8(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  char *arg2 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  sword::RawLD4 *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_RawLD4" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_RawLD4" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    try {
      result = (sword::RawLD4 *)new sword::RawLD4((char const *)arg1,(char const *)arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__RawLD4, SWIG_POINTER_NEW |  0 );
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RawLD4__SWIG_9(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  sword::RawLD4 *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_RawLD4" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  {
    try {
      result = (sword::RawLD4 *)new sword::RawLD4((char const *)arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__RawLD4, SWIG_POINTER_NEW |  0 );
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RawLD4(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[11] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_RawLD4", 0, 10, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_RawLD4__SWIG_9(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_RawLD4__SWIG_8(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_new_RawLD4__SWIG_7(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_sword__SWDisplay, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_new_RawLD4__SWIG_6(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_sword__SWDisplay, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_char(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_new_RawLD4__SWIG_5(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_sword__SWDisplay, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_char(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_char(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_new_RawLD4__SWIG_4(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v = 0;
    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_sword__SWDisplay, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_char(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_char(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_char(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_new_RawLD4__SWIG_3(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v = 0;
    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_sword__SWDisplay, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_char(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_char(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_char(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  int res = SWIG_AsCharPtrAndSize(argv[7], 0, NULL, 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    return _wrap_new_RawLD4__SWIG_2(self, argc, argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v = 0;
    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_sword__SWDisplay, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_char(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_char(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_char(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  int res = SWIG_AsCharPtrAndSize(argv[7], 0, NULL, 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    {
                      int res = SWIG_AsVal_bool(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      return _wrap_new_RawLD4__SWIG_1(self, argc, argv);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 10) {
    int _v = 0;
    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_sword__SWDisplay, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_char(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_char(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_char(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  int res = SWIG_AsCharPtrAndSize(argv[7], 0, NULL, 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    {
                      int res = SWIG_AsVal_bool(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_bool(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        return _wrap_new_RawLD4__SWIG_0(self, argc, argv);
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_RawLD4'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    sword::RawLD4::RawLD4(char const *,char const *,char const *,sword::SWDisplay *,char,char,char,char const *,bool,bool)\n"
    "    sword::RawLD4::RawLD4(char const *,char const *,char const *,sword::SWDisplay *,char,char,char,char const *,bool)\n"
    "    sword::RawLD4::RawLD4(char const *,char const *,char const *,sword::SWDisplay *,char,char,char,char const *)\n"
    "    sword::RawLD4::RawLD4(char const *,char const *,char const *,sword::SWDisplay *,char,char,char)\n"
    "    sword::RawLD4::RawLD4(char const *,char const *,char const *,sword::SWDisplay *,char,char)\n"
    "    sword::RawLD4::RawLD4(char const *,char const *,char const *,sword::SWDisplay *,char)\n"
    "    sword::RawLD4::RawLD4(char const *,char const *,char const *,sword::SWDisplay *)\n"
    "    sword::RawLD4::RawLD4(char const *,char const *,char const *)\n"
    "    sword::RawLD4::RawLD4(char const *,char const *)\n"
    "    sword::RawLD4::RawLD4(char const *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_RawLD4(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::RawLD4 *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__RawLD4, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RawLD4" "', argument " "1"" of type '" "sword::RawLD4 *""'"); 
  }
  arg1 = reinterpret_cast< sword::RawLD4 * >(argp1);
  {
    try {
      delete arg1; 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RawLD4_getRawEntryBuf(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::RawLD4 *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  sword::SWBuf *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__RawLD4, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RawLD4_getRawEntryBuf" "', argument " "1"" of type '" "sword::RawLD4 const *""'"); 
  }
  arg1 = reinterpret_cast< sword::RawLD4 * >(argp1);
  {
    try {
      result = (sword::SWBuf *) &((sword::RawLD4 const *)arg1)->getRawEntryBuf(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__SWBuf, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RawLD4_increment__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::RawLD4 *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__RawLD4, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RawLD4_increment" "', argument " "1"" of type '" "sword::RawLD4 *""'"); 
  }
  arg1 = reinterpret_cast< sword::RawLD4 * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RawLD4_increment" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    try {
      (arg1)->increment(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RawLD4_increment__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::RawLD4 *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__RawLD4, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RawLD4_increment" "', argument " "1"" of type '" "sword::RawLD4 *""'"); 
  }
  arg1 = reinterpret_cast< sword::RawLD4 * >(argp1);
  {
    try {
      (arg1)->increment(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RawLD4_increment(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "RawLD4_increment", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__RawLD4, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_RawLD4_increment__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__RawLD4, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_RawLD4_increment__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'RawLD4_increment'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    sword::RawLD4::increment(int)\n"
    "    sword::RawLD4::increment()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_RawLD4_decrement__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::RawLD4 *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__RawLD4, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RawLD4_decrement" "', argument " "1"" of type '" "sword::RawLD4 *""'"); 
  }
  arg1 = reinterpret_cast< sword::RawLD4 * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RawLD4_decrement" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    try {
      (arg1)->decrement(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RawLD4_decrement__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::RawLD4 *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__RawLD4, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RawLD4_decrement" "', argument " "1"" of type '" "sword::RawLD4 *""'"); 
  }
  arg1 = reinterpret_cast< sword::RawLD4 * >(argp1);
  {
    try {
      (arg1)->decrement(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RawLD4_decrement(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "RawLD4_decrement", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__RawLD4, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_RawLD4_decrement__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__RawLD4, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_RawLD4_decrement__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'RawLD4_decrement'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    sword::RawLD4::decrement(int)\n"
    "    sword::RawLD4::decrement()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_RawLD4_isWritable(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::RawLD4 *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__RawLD4, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RawLD4_isWritable" "', argument " "1"" of type '" "sword::RawLD4 const *""'"); 
  }
  arg1 = reinterpret_cast< sword::RawLD4 * >(argp1);
  {
    try {
      result = (bool)((sword::RawLD4 const *)arg1)->isWritable(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RawLD4_createModule(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  PyObject *swig_obj[1] ;
  char result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RawLD4_createModule" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  {
    try {
      result = (char)sword::RawLD4::createModule((char const *)arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_char(static_cast< char >(result));
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_RawLD4_setEntry__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::RawLD4 *arg1 = 0 ;
  char *arg2 = 0 ;
  long arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  long val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__RawLD4, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RawLD4_setEntry" "', argument " "1"" of type '" "sword::RawLD4 *""'"); 
  }
  arg1 = reinterpret_cast< sword::RawLD4 * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RawLD4_setEntry" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  ecode3 = SWIG_AsVal_long(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RawLD4_setEntry" "', argument " "3"" of type '" "long""'");
  } 
  arg3 = static_cast< long >(val3);
  {
    try {
      (arg1)->setEntry((char const *)arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_RawLD4_setEntry__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::RawLD4 *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__RawLD4, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RawLD4_setEntry" "', argument " "1"" of type '" "sword::RawLD4 *""'"); 
  }
  arg1 = reinterpret_cast< sword::RawLD4 * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RawLD4_setEntry" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    try {
      (arg1)->setEntry((char const *)arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_RawLD4_setEntry(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "RawLD4_setEntry", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__RawLD4, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_RawLD4_setEntry__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__RawLD4, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_long(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_RawLD4_setEntry__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'RawLD4_setEntry'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    sword::RawLD4::setEntry(char const *,long)\n"
    "    sword::RawLD4::setEntry(char const *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_RawLD4_linkEntry(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::RawLD4 *arg1 = 0 ;
  sword::SWKey *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "RawLD4_linkEntry", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__RawLD4, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RawLD4_linkEntry" "', argument " "1"" of type '" "sword::RawLD4 *""'"); 
  }
  arg1 = reinterpret_cast< sword::RawLD4 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_sword__SWKey, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RawLD4_linkEntry" "', argument " "2"" of type '" "sword::SWKey const *""'"); 
  }
  arg2 = reinterpret_cast< sword::SWKey * >(argp2);
  {
    try {
      (arg1)->linkEntry((sword::SWKey const *)arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RawLD4_deleteEntry(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::RawLD4 *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__RawLD4, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RawLD4_deleteEntry" "', argument " "1"" of type '" "sword::RawLD4 *""'"); 
  }
  arg1 = reinterpret_cast< sword::RawLD4 * >(argp1);
  {
    try {
      (arg1)->deleteEntry(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RawLD4_getEntryCount(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::RawLD4 *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  long result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__RawLD4, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RawLD4_getEntryCount" "', argument " "1"" of type '" "sword::RawLD4 const *""'"); 
  }
  arg1 = reinterpret_cast< sword::RawLD4 * >(argp1);
  {
    try {
      result = (long)((sword::RawLD4 const *)arg1)->getEntryCount(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_long(static_cast< long >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RawLD4_getEntryForKey(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::RawLD4 *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  long result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "RawLD4_getEntryForKey", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__RawLD4, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RawLD4_getEntryForKey" "', argument " "1"" of type '" "sword::RawLD4 const *""'"); 
  }
  arg1 = reinterpret_cast< sword::RawLD4 * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RawLD4_getEntryForKey" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    try {
      result = (long)((sword::RawLD4 const *)arg1)->getEntryForKey((char const *)arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_long(static_cast< long >(result));
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_RawLD4_getKeyForEntry(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::RawLD4 *arg1 = 0 ;
  long arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  long val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  char *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "RawLD4_getKeyForEntry", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__RawLD4, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RawLD4_getKeyForEntry" "', argument " "1"" of type '" "sword::RawLD4 const *""'"); 
  }
  arg1 = reinterpret_cast< sword::RawLD4 * >(argp1);
  ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RawLD4_getKeyForEntry" "', argument " "2"" of type '" "long""'");
  } 
  arg2 = static_cast< long >(val2);
  {
    try {
      result = (char *)((sword::RawLD4 const *)arg1)->getKeyForEntry(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RawLD4___lshift____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::RawLD4 *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  sword::SWModule *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__RawLD4, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RawLD4___lshift__" "', argument " "1"" of type '" "sword::RawLD4 *""'"); 
  }
  arg1 = reinterpret_cast< sword::RawLD4 * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RawLD4___lshift__" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    try {
      result = (sword::SWModule *) &(arg1)->operator <<((char const *)arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__SWModule, 0 |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_RawLD4___lshift____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::RawLD4 *arg1 = 0 ;
  sword::SWKey *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  sword::SWModule *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__RawLD4, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RawLD4___lshift__" "', argument " "1"" of type '" "sword::RawLD4 *""'"); 
  }
  arg1 = reinterpret_cast< sword::RawLD4 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_sword__SWKey, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RawLD4___lshift__" "', argument " "2"" of type '" "sword::SWKey const *""'"); 
  }
  arg2 = reinterpret_cast< sword::SWKey * >(argp2);
  {
    try {
      result = (sword::SWModule *) &(arg1)->operator <<((sword::SWKey const *)arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__SWModule, 0 |  0 );
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_RawLD4___lshift__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "RawLD4___lshift__", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__RawLD4, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_sword__SWKey, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_RawLD4___lshift____SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__RawLD4, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_RawLD4___lshift____SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_RawLD4___isub__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::RawLD4 *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  sword::SWModule *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "RawLD4___isub__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__RawLD4, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RawLD4___isub__" "', argument " "1"" of type '" "sword::RawLD4 *""'"); 
  }
  arg1 = reinterpret_cast< sword::RawLD4 * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RawLD4___isub__" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    try {
      result = (sword::SWModule *) &(arg1)->operator -=(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__SWModule, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RawLD4___iadd__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::RawLD4 *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  sword::SWModule *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "RawLD4___iadd__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__RawLD4, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RawLD4___iadd__" "', argument " "1"" of type '" "sword::RawLD4 *""'"); 
  }
  arg1 = reinterpret_cast< sword::RawLD4 * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RawLD4___iadd__" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    try {
      result = (sword::SWModule *) &(arg1)->operator +=(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__SWModule, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RawLD4_castTo(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWModule *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  sword::RawLD4 *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RawLD4_castTo" "', argument " "1"" of type '" "sword::SWModule *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWModule * >(argp1);
  {
    try {
      result = (sword::RawLD4 *)sword_RawLD4_castTo(arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__RawLD4, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *RawLD4_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_sword__RawLD4, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *RawLD4_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_zLD__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  char *arg2 = 0 ;
  char *arg3 = 0 ;
  long arg4 ;
  sword::SWCompress *arg5 = 0 ;
  sword::SWDisplay *arg6 = 0 ;
  char arg7 ;
  char arg8 ;
  char arg9 ;
  char *arg10 = 0 ;
  bool arg11 ;
  bool arg12 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  long val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  char val7 ;
  int ecode7 = 0 ;
  char val8 ;
  int ecode8 = 0 ;
  char val9 ;
  int ecode9 = 0 ;
  int res10 ;
  char *buf10 = 0 ;
  int alloc10 = 0 ;
  bool val11 ;
  int ecode11 = 0 ;
  bool val12 ;
  int ecode12 = 0 ;
  sword::zLD *result = 0 ;
  
  (void)self;
  if ((nobjs < 12) || (nobjs > 12)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_zLD" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_zLD" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_zLD" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  ecode4 = SWIG_AsVal_long(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_zLD" "', argument " "4"" of type '" "long""'");
  } 
  arg4 = static_cast< long >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5,SWIGTYPE_p_sword__SWCompress, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_zLD" "', argument " "5"" of type '" "sword::SWCompress *""'"); 
  }
  arg5 = reinterpret_cast< sword::SWCompress * >(argp5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6,SWIGTYPE_p_sword__SWDisplay, 0 |  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_zLD" "', argument " "6"" of type '" "sword::SWDisplay *""'"); 
  }
  arg6 = reinterpret_cast< sword::SWDisplay * >(argp6);
  ecode7 = SWIG_AsVal_char(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_zLD" "', argument " "7"" of type '" "char""'");
  } 
  arg7 = static_cast< char >(val7);
  ecode8 = SWIG_AsVal_char(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_zLD" "', argument " "8"" of type '" "char""'");
  } 
  arg8 = static_cast< char >(val8);
  ecode9 = SWIG_AsVal_char(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_zLD" "', argument " "9"" of type '" "char""'");
  } 
  arg9 = static_cast< char >(val9);
  res10 = SWIG_AsCharPtrAndSize(swig_obj[9], &buf10, NULL, &alloc10);
  if (!SWIG_IsOK(res10)) {
    SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "new_zLD" "', argument " "10"" of type '" "char const *""'");
  }
  arg10 = reinterpret_cast< char * >(buf10);
  ecode11 = SWIG_AsVal_bool(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_zLD" "', argument " "11"" of type '" "bool""'");
  } 
  arg11 = static_cast< bool >(val11);
  ecode12 = SWIG_AsVal_bool(swig_obj[11], &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_zLD" "', argument " "12"" of type '" "bool""'");
  } 
  arg12 = static_cast< bool >(val12);
  {
    try {
      result = (sword::zLD *)new sword::zLD((char const *)arg1,(char const *)arg2,(char const *)arg3,arg4,arg5,arg6,arg7,arg8,arg9,(char const *)arg10,arg11,arg12); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__zLD, SWIG_POINTER_NEW |  0 );
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  if (alloc10 == SWIG_NEWOBJ) delete[] buf10;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  if (alloc10 == SWIG_NEWOBJ) delete[] buf10;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_zLD__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  char *arg2 = 0 ;
  char *arg3 = 0 ;
  long arg4 ;
  sword::SWCompress *arg5 = 0 ;
  sword::SWDisplay *arg6 = 0 ;
  char arg7 ;
  char arg8 ;
  char arg9 ;
  char *arg10 = 0 ;
  bool arg11 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  long val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  char val7 ;
  int ecode7 = 0 ;
  char val8 ;
  int ecode8 = 0 ;
  char val9 ;
  int ecode9 = 0 ;
  int res10 ;
  char *buf10 = 0 ;
  int alloc10 = 0 ;
  bool val11 ;
  int ecode11 = 0 ;
  sword::zLD *result = 0 ;
  
  (void)self;
  if ((nobjs < 11) || (nobjs > 11)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_zLD" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_zLD" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_zLD" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  ecode4 = SWIG_AsVal_long(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_zLD" "', argument " "4"" of type '" "long""'");
  } 
  arg4 = static_cast< long >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5,SWIGTYPE_p_sword__SWCompress, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_zLD" "', argument " "5"" of type '" "sword::SWCompress *""'"); 
  }
  arg5 = reinterpret_cast< sword::SWCompress * >(argp5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6,SWIGTYPE_p_sword__SWDisplay, 0 |  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_zLD" "', argument " "6"" of type '" "sword::SWDisplay *""'"); 
  }
  arg6 = reinterpret_cast< sword::SWDisplay * >(argp6);
  ecode7 = SWIG_AsVal_char(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_zLD" "', argument " "7"" of type '" "char""'");
  } 
  arg7 = static_cast< char >(val7);
  ecode8 = SWIG_AsVal_char(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_zLD" "', argument " "8"" of type '" "char""'");
  } 
  arg8 = static_cast< char >(val8);
  ecode9 = SWIG_AsVal_char(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_zLD" "', argument " "9"" of type '" "char""'");
  } 
  arg9 = static_cast< char >(val9);
  res10 = SWIG_AsCharPtrAndSize(swig_obj[9], &buf10, NULL, &alloc10);
  if (!SWIG_IsOK(res10)) {
    SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "new_zLD" "', argument " "10"" of type '" "char const *""'");
  }
  arg10 = reinterpret_cast< char * >(buf10);
  ecode11 = SWIG_AsVal_bool(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_zLD" "', argument " "11"" of type '" "bool""'");
  } 
  arg11 = static_cast< bool >(val11);
  {
    try {
      result = (sword::zLD *)new sword::zLD((char const *)arg1,(char const *)arg2,(char const *)arg3,arg4,arg5,arg6,arg7,arg8,arg9,(char const *)arg10,arg11); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__zLD, SWIG_POINTER_NEW |  0 );
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  if (alloc10 == SWIG_NEWOBJ) delete[] buf10;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  if (alloc10 == SWIG_NEWOBJ) delete[] buf10;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_zLD__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  char *arg2 = 0 ;
  char *arg3 = 0 ;
  long arg4 ;
  sword::SWCompress *arg5 = 0 ;
  sword::SWDisplay *arg6 = 0 ;
  char arg7 ;
  char arg8 ;
  char arg9 ;
  char *arg10 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  long val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  char val7 ;
  int ecode7 = 0 ;
  char val8 ;
  int ecode8 = 0 ;
  char val9 ;
  int ecode9 = 0 ;
  int res10 ;
  char *buf10 = 0 ;
  int alloc10 = 0 ;
  sword::zLD *result = 0 ;
  
  (void)self;
  if ((nobjs < 10) || (nobjs > 10)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_zLD" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_zLD" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_zLD" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  ecode4 = SWIG_AsVal_long(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_zLD" "', argument " "4"" of type '" "long""'");
  } 
  arg4 = static_cast< long >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5,SWIGTYPE_p_sword__SWCompress, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_zLD" "', argument " "5"" of type '" "sword::SWCompress *""'"); 
  }
  arg5 = reinterpret_cast< sword::SWCompress * >(argp5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6,SWIGTYPE_p_sword__SWDisplay, 0 |  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_zLD" "', argument " "6"" of type '" "sword::SWDisplay *""'"); 
  }
  arg6 = reinterpret_cast< sword::SWDisplay * >(argp6);
  ecode7 = SWIG_AsVal_char(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_zLD" "', argument " "7"" of type '" "char""'");
  } 
  arg7 = static_cast< char >(val7);
  ecode8 = SWIG_AsVal_char(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_zLD" "', argument " "8"" of type '" "char""'");
  } 
  arg8 = static_cast< char >(val8);
  ecode9 = SWIG_AsVal_char(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_zLD" "', argument " "9"" of type '" "char""'");
  } 
  arg9 = static_cast< char >(val9);
  res10 = SWIG_AsCharPtrAndSize(swig_obj[9], &buf10, NULL, &alloc10);
  if (!SWIG_IsOK(res10)) {
    SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "new_zLD" "', argument " "10"" of type '" "char const *""'");
  }
  arg10 = reinterpret_cast< char * >(buf10);
  {
    try {
      result = (sword::zLD *)new sword::zLD((char const *)arg1,(char const *)arg2,(char const *)arg3,arg4,arg5,arg6,arg7,arg8,arg9,(char const *)arg10); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__zLD, SWIG_POINTER_NEW |  0 );
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  if (alloc10 == SWIG_NEWOBJ) delete[] buf10;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  if (alloc10 == SWIG_NEWOBJ) delete[] buf10;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_zLD__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  char *arg2 = 0 ;
  char *arg3 = 0 ;
  long arg4 ;
  sword::SWCompress *arg5 = 0 ;
  sword::SWDisplay *arg6 = 0 ;
  char arg7 ;
  char arg8 ;
  char arg9 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  long val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  char val7 ;
  int ecode7 = 0 ;
  char val8 ;
  int ecode8 = 0 ;
  char val9 ;
  int ecode9 = 0 ;
  sword::zLD *result = 0 ;
  
  (void)self;
  if ((nobjs < 9) || (nobjs > 9)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_zLD" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_zLD" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_zLD" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  ecode4 = SWIG_AsVal_long(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_zLD" "', argument " "4"" of type '" "long""'");
  } 
  arg4 = static_cast< long >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5,SWIGTYPE_p_sword__SWCompress, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_zLD" "', argument " "5"" of type '" "sword::SWCompress *""'"); 
  }
  arg5 = reinterpret_cast< sword::SWCompress * >(argp5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6,SWIGTYPE_p_sword__SWDisplay, 0 |  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_zLD" "', argument " "6"" of type '" "sword::SWDisplay *""'"); 
  }
  arg6 = reinterpret_cast< sword::SWDisplay * >(argp6);
  ecode7 = SWIG_AsVal_char(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_zLD" "', argument " "7"" of type '" "char""'");
  } 
  arg7 = static_cast< char >(val7);
  ecode8 = SWIG_AsVal_char(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_zLD" "', argument " "8"" of type '" "char""'");
  } 
  arg8 = static_cast< char >(val8);
  ecode9 = SWIG_AsVal_char(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_zLD" "', argument " "9"" of type '" "char""'");
  } 
  arg9 = static_cast< char >(val9);
  {
    try {
      result = (sword::zLD *)new sword::zLD((char const *)arg1,(char const *)arg2,(char const *)arg3,arg4,arg5,arg6,arg7,arg8,arg9); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__zLD, SWIG_POINTER_NEW |  0 );
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_zLD__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  char *arg2 = 0 ;
  char *arg3 = 0 ;
  long arg4 ;
  sword::SWCompress *arg5 = 0 ;
  sword::SWDisplay *arg6 = 0 ;
  char arg7 ;
  char arg8 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  long val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  char val7 ;
  int ecode7 = 0 ;
  char val8 ;
  int ecode8 = 0 ;
  sword::zLD *result = 0 ;
  
  (void)self;
  if ((nobjs < 8) || (nobjs > 8)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_zLD" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_zLD" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_zLD" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  ecode4 = SWIG_AsVal_long(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_zLD" "', argument " "4"" of type '" "long""'");
  } 
  arg4 = static_cast< long >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5,SWIGTYPE_p_sword__SWCompress, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_zLD" "', argument " "5"" of type '" "sword::SWCompress *""'"); 
  }
  arg5 = reinterpret_cast< sword::SWCompress * >(argp5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6,SWIGTYPE_p_sword__SWDisplay, 0 |  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_zLD" "', argument " "6"" of type '" "sword::SWDisplay *""'"); 
  }
  arg6 = reinterpret_cast< sword::SWDisplay * >(argp6);
  ecode7 = SWIG_AsVal_char(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_zLD" "', argument " "7"" of type '" "char""'");
  } 
  arg7 = static_cast< char >(val7);
  ecode8 = SWIG_AsVal_char(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_zLD" "', argument " "8"" of type '" "char""'");
  } 
  arg8 = static_cast< char >(val8);
  {
    try {
      result = (sword::zLD *)new sword::zLD((char const *)arg1,(char const *)arg2,(char const *)arg3,arg4,arg5,arg6,arg7,arg8); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__zLD, SWIG_POINTER_NEW |  0 );
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_zLD__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  char *arg2 = 0 ;
  char *arg3 = 0 ;
  long arg4 ;
  sword::SWCompress *arg5 = 0 ;
  sword::SWDisplay *arg6 = 0 ;
  char arg7 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  long val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  char val7 ;
  int ecode7 = 0 ;
  sword::zLD *result = 0 ;
  
  (void)self;
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_zLD" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_zLD" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_zLD" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  ecode4 = SWIG_AsVal_long(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_zLD" "', argument " "4"" of type '" "long""'");
  } 
  arg4 = static_cast< long >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5,SWIGTYPE_p_sword__SWCompress, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_zLD" "', argument " "5"" of type '" "sword::SWCompress *""'"); 
  }
  arg5 = reinterpret_cast< sword::SWCompress * >(argp5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6,SWIGTYPE_p_sword__SWDisplay, 0 |  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_zLD" "', argument " "6"" of type '" "sword::SWDisplay *""'"); 
  }
  arg6 = reinterpret_cast< sword::SWDisplay * >(argp6);
  ecode7 = SWIG_AsVal_char(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_zLD" "', argument " "7"" of type '" "char""'");
  } 
  arg7 = static_cast< char >(val7);
  {
    try {
      result = (sword::zLD *)new sword::zLD((char const *)arg1,(char const *)arg2,(char const *)arg3,arg4,arg5,arg6,arg7); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__zLD, SWIG_POINTER_NEW |  0 );
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_zLD__SWIG_6(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  char *arg2 = 0 ;
  char *arg3 = 0 ;
  long arg4 ;
  sword::SWCompress *arg5 = 0 ;
  sword::SWDisplay *arg6 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  long val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  sword::zLD *result = 0 ;
  
  (void)self;
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_zLD" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_zLD" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_zLD" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  ecode4 = SWIG_AsVal_long(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_zLD" "', argument " "4"" of type '" "long""'");
  } 
  arg4 = static_cast< long >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5,SWIGTYPE_p_sword__SWCompress, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_zLD" "', argument " "5"" of type '" "sword::SWCompress *""'"); 
  }
  arg5 = reinterpret_cast< sword::SWCompress * >(argp5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6,SWIGTYPE_p_sword__SWDisplay, 0 |  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_zLD" "', argument " "6"" of type '" "sword::SWDisplay *""'"); 
  }
  arg6 = reinterpret_cast< sword::SWDisplay * >(argp6);
  {
    try {
      result = (sword::zLD *)new sword::zLD((char const *)arg1,(char const *)arg2,(char const *)arg3,arg4,arg5,arg6); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__zLD, SWIG_POINTER_NEW |  0 );
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_zLD__SWIG_7(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  char *arg2 = 0 ;
  char *arg3 = 0 ;
  long arg4 ;
  sword::SWCompress *arg5 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  long val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  sword::zLD *result = 0 ;
  
  (void)self;
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_zLD" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_zLD" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_zLD" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  ecode4 = SWIG_AsVal_long(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_zLD" "', argument " "4"" of type '" "long""'");
  } 
  arg4 = static_cast< long >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5,SWIGTYPE_p_sword__SWCompress, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_zLD" "', argument " "5"" of type '" "sword::SWCompress *""'"); 
  }
  arg5 = reinterpret_cast< sword::SWCompress * >(argp5);
  {
    try {
      result = (sword::zLD *)new sword::zLD((char const *)arg1,(char const *)arg2,(char const *)arg3,arg4,arg5); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__zLD, SWIG_POINTER_NEW |  0 );
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_zLD__SWIG_8(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  char *arg2 = 0 ;
  char *arg3 = 0 ;
  long arg4 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  long val4 ;
  int ecode4 = 0 ;
  sword::zLD *result = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_zLD" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_zLD" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_zLD" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  ecode4 = SWIG_AsVal_long(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_zLD" "', argument " "4"" of type '" "long""'");
  } 
  arg4 = static_cast< long >(val4);
  {
    try {
      result = (sword::zLD *)new sword::zLD((char const *)arg1,(char const *)arg2,(char const *)arg3,arg4); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__zLD, SWIG_POINTER_NEW |  0 );
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_zLD__SWIG_9(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  char *arg2 = 0 ;
  char *arg3 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  sword::zLD *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_zLD" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_zLD" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_zLD" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  {
    try {
      result = (sword::zLD *)new sword::zLD((char const *)arg1,(char const *)arg2,(char const *)arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__zLD, SWIG_POINTER_NEW |  0 );
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_zLD__SWIG_10(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  char *arg2 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  sword::zLD *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_zLD" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_zLD" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    try {
      result = (sword::zLD *)new sword::zLD((char const *)arg1,(char const *)arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__zLD, SWIG_POINTER_NEW |  0 );
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_zLD__SWIG_11(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  sword::zLD *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_zLD" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  {
    try {
      result = (sword::zLD *)new sword::zLD((char const *)arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__zLD, SWIG_POINTER_NEW |  0 );
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_zLD(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[13] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_zLD", 0, 12, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_zLD__SWIG_11(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_zLD__SWIG_10(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_new_zLD__SWIG_9(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_long(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_new_zLD__SWIG_8(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_long(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_sword__SWCompress, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_new_zLD__SWIG_7(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_long(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_sword__SWCompress, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_sword__SWDisplay, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                return _wrap_new_zLD__SWIG_6(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v = 0;
    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_long(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_sword__SWCompress, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_sword__SWDisplay, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_char(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_new_zLD__SWIG_5(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v = 0;
    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_long(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_sword__SWCompress, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_sword__SWDisplay, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_char(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_char(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    return _wrap_new_zLD__SWIG_4(self, argc, argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v = 0;
    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_long(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_sword__SWCompress, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_sword__SWDisplay, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_char(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_char(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_char(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      return _wrap_new_zLD__SWIG_3(self, argc, argv);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 10) {
    int _v = 0;
    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_long(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_sword__SWCompress, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_sword__SWDisplay, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_char(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_char(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_char(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      int res = SWIG_AsCharPtrAndSize(argv[9], 0, NULL, 0);
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        return _wrap_new_zLD__SWIG_2(self, argc, argv);
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 11) {
    int _v = 0;
    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_long(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_sword__SWCompress, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_sword__SWDisplay, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_char(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_char(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_char(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      int res = SWIG_AsCharPtrAndSize(argv[9], 0, NULL, 0);
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        {
                          int res = SWIG_AsVal_bool(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          return _wrap_new_zLD__SWIG_1(self, argc, argv);
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 12) {
    int _v = 0;
    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_long(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_sword__SWCompress, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_sword__SWDisplay, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_char(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_char(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_char(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      int res = SWIG_AsCharPtrAndSize(argv[9], 0, NULL, 0);
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        {
                          int res = SWIG_AsVal_bool(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_bool(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            return _wrap_new_zLD__SWIG_0(self, argc, argv);
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_zLD'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    sword::zLD::zLD(char const *,char const *,char const *,long,sword::SWCompress *,sword::SWDisplay *,char,char,char,char const *,bool,bool)\n"
    "    sword::zLD::zLD(char const *,char const *,char const *,long,sword::SWCompress *,sword::SWDisplay *,char,char,char,char const *,bool)\n"
    "    sword::zLD::zLD(char const *,char const *,char const *,long,sword::SWCompress *,sword::SWDisplay *,char,char,char,char const *)\n"
    "    sword::zLD::zLD(char const *,char const *,char const *,long,sword::SWCompress *,sword::SWDisplay *,char,char,char)\n"
    "    sword::zLD::zLD(char const *,char const *,char const *,long,sword::SWCompress *,sword::SWDisplay *,char,char)\n"
    "    sword::zLD::zLD(char const *,char const *,char const *,long,sword::SWCompress *,sword::SWDisplay *,char)\n"
    "    sword::zLD::zLD(char const *,char const *,char const *,long,sword::SWCompress *,sword::SWDisplay *)\n"
    "    sword::zLD::zLD(char const *,char const *,char const *,long,sword::SWCompress *)\n"
    "    sword::zLD::zLD(char const *,char const *,char const *,long)\n"
    "    sword::zLD::zLD(char const *,char const *,char const *)\n"
    "    sword::zLD::zLD(char const *,char const *)\n"
    "    sword::zLD::zLD(char const *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_zLD(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::zLD *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__zLD, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_zLD" "', argument " "1"" of type '" "sword::zLD *""'"); 
  }
  arg1 = reinterpret_cast< sword::zLD * >(argp1);
  {
    try {
      delete arg1; 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_zLD_getRawEntryBuf(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::zLD *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  sword::SWBuf *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__zLD, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "zLD_getRawEntryBuf" "', argument " "1"" of type '" "sword::zLD const *""'"); 
  }
  arg1 = reinterpret_cast< sword::zLD * >(argp1);
  {
    try {
      result = (sword::SWBuf *) &((sword::zLD const *)arg1)->getRawEntryBuf(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__SWBuf, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_zLD_increment__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::zLD *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__zLD, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "zLD_increment" "', argument " "1"" of type '" "sword::zLD *""'"); 
  }
  arg1 = reinterpret_cast< sword::zLD * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "zLD_increment" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    try {
      (arg1)->increment(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_zLD_increment__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::zLD *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__zLD, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "zLD_increment" "', argument " "1"" of type '" "sword::zLD *""'"); 
  }
  arg1 = reinterpret_cast< sword::zLD * >(argp1);
  {
    try {
      (arg1)->increment(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_zLD_increment(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "zLD_increment", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__zLD, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_zLD_increment__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__zLD, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_zLD_increment__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'zLD_increment'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    sword::zLD::increment(int)\n"
    "    sword::zLD::increment()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_zLD_decrement__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::zLD *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__zLD, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "zLD_decrement" "', argument " "1"" of type '" "sword::zLD *""'"); 
  }
  arg1 = reinterpret_cast< sword::zLD * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "zLD_decrement" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    try {
      (arg1)->decrement(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_zLD_decrement__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::zLD *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__zLD, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "zLD_decrement" "', argument " "1"" of type '" "sword::zLD *""'"); 
  }
  arg1 = reinterpret_cast< sword::zLD * >(argp1);
  {
    try {
      (arg1)->decrement(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_zLD_decrement(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "zLD_decrement", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__zLD, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_zLD_decrement__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__zLD, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_zLD_decrement__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'zLD_decrement'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    sword::zLD::decrement(int)\n"
    "    sword::zLD::decrement()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_zLD_isWritable(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::zLD *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__zLD, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "zLD_isWritable" "', argument " "1"" of type '" "sword::zLD const *""'"); 
  }
  arg1 = reinterpret_cast< sword::zLD * >(argp1);
  {
    try {
      result = (bool)((sword::zLD const *)arg1)->isWritable(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_zLD_createModule(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  PyObject *swig_obj[1] ;
  char result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "zLD_createModule" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  {
    try {
      result = (char)sword::zLD::createModule((char const *)arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_char(static_cast< char >(result));
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_zLD_setEntry__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::zLD *arg1 = 0 ;
  char *arg2 = 0 ;
  long arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  long val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__zLD, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "zLD_setEntry" "', argument " "1"" of type '" "sword::zLD *""'"); 
  }
  arg1 = reinterpret_cast< sword::zLD * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "zLD_setEntry" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  ecode3 = SWIG_AsVal_long(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "zLD_setEntry" "', argument " "3"" of type '" "long""'");
  } 
  arg3 = static_cast< long >(val3);
  {
    try {
      (arg1)->setEntry((char const *)arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_zLD_setEntry__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::zLD *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__zLD, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "zLD_setEntry" "', argument " "1"" of type '" "sword::zLD *""'"); 
  }
  arg1 = reinterpret_cast< sword::zLD * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "zLD_setEntry" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    try {
      (arg1)->setEntry((char const *)arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_zLD_setEntry(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "zLD_setEntry", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__zLD, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_zLD_setEntry__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__zLD, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_long(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_zLD_setEntry__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'zLD_setEntry'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    sword::zLD::setEntry(char const *,long)\n"
    "    sword::zLD::setEntry(char const *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_zLD_linkEntry(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::zLD *arg1 = 0 ;
  sword::SWKey *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "zLD_linkEntry", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__zLD, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "zLD_linkEntry" "', argument " "1"" of type '" "sword::zLD *""'"); 
  }
  arg1 = reinterpret_cast< sword::zLD * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_sword__SWKey, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "zLD_linkEntry" "', argument " "2"" of type '" "sword::SWKey const *""'"); 
  }
  arg2 = reinterpret_cast< sword::SWKey * >(argp2);
  {
    try {
      (arg1)->linkEntry((sword::SWKey const *)arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_zLD_deleteEntry(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::zLD *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__zLD, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "zLD_deleteEntry" "', argument " "1"" of type '" "sword::zLD *""'"); 
  }
  arg1 = reinterpret_cast< sword::zLD * >(argp1);
  {
    try {
      (arg1)->deleteEntry(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_zLD_rawZFilter__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::zLD *arg1 = 0 ;
  sword::SWBuf *arg2 = 0 ;
  char arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  char val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__zLD, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "zLD_rawZFilter" "', argument " "1"" of type '" "sword::zLD const *""'"); 
  }
  arg1 = reinterpret_cast< sword::zLD * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_sword__SWBuf,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "zLD_rawZFilter" "', argument " "2"" of type '" "sword::SWBuf &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "zLD_rawZFilter" "', argument " "2"" of type '" "sword::SWBuf &""'"); 
  }
  arg2 = reinterpret_cast< sword::SWBuf * >(argp2);
  ecode3 = SWIG_AsVal_char(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "zLD_rawZFilter" "', argument " "3"" of type '" "char""'");
  } 
  arg3 = static_cast< char >(val3);
  {
    try {
      ((sword::zLD const *)arg1)->rawZFilter(*arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_zLD_rawZFilter__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::zLD *arg1 = 0 ;
  sword::SWBuf *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__zLD, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "zLD_rawZFilter" "', argument " "1"" of type '" "sword::zLD const *""'"); 
  }
  arg1 = reinterpret_cast< sword::zLD * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_sword__SWBuf,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "zLD_rawZFilter" "', argument " "2"" of type '" "sword::SWBuf &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "zLD_rawZFilter" "', argument " "2"" of type '" "sword::SWBuf &""'"); 
  }
  arg2 = reinterpret_cast< sword::SWBuf * >(argp2);
  {
    try {
      ((sword::zLD const *)arg1)->rawZFilter(*arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_zLD_rawZFilter(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "zLD_rawZFilter", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__zLD, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_sword__SWBuf, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_zLD_rawZFilter__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__zLD, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_sword__SWBuf, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_char(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_zLD_rawZFilter__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'zLD_rawZFilter'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    sword::zLD::rawZFilter(sword::SWBuf &,char) const\n"
    "    sword::zLD::rawZFilter(sword::SWBuf &) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_zLD_flush(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::zLD *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__zLD, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "zLD_flush" "', argument " "1"" of type '" "sword::zLD *""'"); 
  }
  arg1 = reinterpret_cast< sword::zLD * >(argp1);
  {
    try {
      (arg1)->flush(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_zLD_getEntryCount(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::zLD *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  long result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__zLD, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "zLD_getEntryCount" "', argument " "1"" of type '" "sword::zLD const *""'"); 
  }
  arg1 = reinterpret_cast< sword::zLD * >(argp1);
  {
    try {
      result = (long)((sword::zLD const *)arg1)->getEntryCount(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_long(static_cast< long >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_zLD_getEntryForKey(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::zLD *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  long result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "zLD_getEntryForKey", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__zLD, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "zLD_getEntryForKey" "', argument " "1"" of type '" "sword::zLD const *""'"); 
  }
  arg1 = reinterpret_cast< sword::zLD * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "zLD_getEntryForKey" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    try {
      result = (long)((sword::zLD const *)arg1)->getEntryForKey((char const *)arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_long(static_cast< long >(result));
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_zLD_getKeyForEntry(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::zLD *arg1 = 0 ;
  long arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  long val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  char *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "zLD_getKeyForEntry", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__zLD, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "zLD_getKeyForEntry" "', argument " "1"" of type '" "sword::zLD const *""'"); 
  }
  arg1 = reinterpret_cast< sword::zLD * >(argp1);
  ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "zLD_getKeyForEntry" "', argument " "2"" of type '" "long""'");
  } 
  arg2 = static_cast< long >(val2);
  {
    try {
      result = (char *)((sword::zLD const *)arg1)->getKeyForEntry(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_zLD___lshift____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::zLD *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  sword::SWModule *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__zLD, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "zLD___lshift__" "', argument " "1"" of type '" "sword::zLD *""'"); 
  }
  arg1 = reinterpret_cast< sword::zLD * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "zLD___lshift__" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    try {
      result = (sword::SWModule *) &(arg1)->operator <<((char const *)arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__SWModule, 0 |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_zLD___lshift____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::zLD *arg1 = 0 ;
  sword::SWKey *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  sword::SWModule *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__zLD, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "zLD___lshift__" "', argument " "1"" of type '" "sword::zLD *""'"); 
  }
  arg1 = reinterpret_cast< sword::zLD * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_sword__SWKey, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "zLD___lshift__" "', argument " "2"" of type '" "sword::SWKey const *""'"); 
  }
  arg2 = reinterpret_cast< sword::SWKey * >(argp2);
  {
    try {
      result = (sword::SWModule *) &(arg1)->operator <<((sword::SWKey const *)arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__SWModule, 0 |  0 );
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_zLD___lshift__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "zLD___lshift__", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__zLD, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_sword__SWKey, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_zLD___lshift____SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__zLD, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_zLD___lshift____SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_zLD___isub__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::zLD *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  sword::SWModule *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "zLD___isub__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__zLD, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "zLD___isub__" "', argument " "1"" of type '" "sword::zLD *""'"); 
  }
  arg1 = reinterpret_cast< sword::zLD * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "zLD___isub__" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    try {
      result = (sword::SWModule *) &(arg1)->operator -=(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__SWModule, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_zLD___iadd__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::zLD *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  sword::SWModule *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "zLD___iadd__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__zLD, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "zLD___iadd__" "', argument " "1"" of type '" "sword::zLD *""'"); 
  }
  arg1 = reinterpret_cast< sword::zLD * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "zLD___iadd__" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    try {
      result = (sword::SWModule *) &(arg1)->operator +=(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__SWModule, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_zLD_castTo(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWModule *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  sword::zLD *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "zLD_castTo" "', argument " "1"" of type '" "sword::SWModule *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWModule * >(argp1);
  {
    try {
      result = (sword::zLD *)sword_zLD_castTo(arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__zLD, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *zLD_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_sword__zLD, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *zLD_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_delete_SWText(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWText *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWText, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SWText" "', argument " "1"" of type '" "sword::SWText *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWText * >(argp1);
  {
    try {
      delete arg1; 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWText_createKey(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWText *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  sword::SWKey *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWText, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWText_createKey" "', argument " "1"" of type '" "sword::SWText const *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWText * >(argp1);
  {
    try {
      result = (sword::SWKey *)((sword::SWText const *)arg1)->createKey(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__SWKey, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWText_getIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWText *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  long result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWText, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWText_getIndex" "', argument " "1"" of type '" "sword::SWText const *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWText * >(argp1);
  {
    try {
      result = (long)((sword::SWText const *)arg1)->getIndex(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_long(static_cast< long >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWText_setIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWText *arg1 = 0 ;
  long arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  long val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SWText_setIndex", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWText, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWText_setIndex" "', argument " "1"" of type '" "sword::SWText *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWText * >(argp1);
  ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SWText_setIndex" "', argument " "2"" of type '" "long""'");
  } 
  arg2 = static_cast< long >(val2);
  {
    try {
      (arg1)->setIndex(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWText___lshift____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::SWText *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  sword::SWModule *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWText, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWText___lshift__" "', argument " "1"" of type '" "sword::SWText *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWText * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SWText___lshift__" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    try {
      result = (sword::SWModule *) &(arg1)->operator <<((char const *)arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__SWModule, 0 |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SWText___lshift____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::SWText *arg1 = 0 ;
  sword::SWKey *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  sword::SWModule *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWText, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWText___lshift__" "', argument " "1"" of type '" "sword::SWText *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWText * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_sword__SWKey, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SWText___lshift__" "', argument " "2"" of type '" "sword::SWKey const *""'"); 
  }
  arg2 = reinterpret_cast< sword::SWKey * >(argp2);
  {
    try {
      result = (sword::SWModule *) &(arg1)->operator <<((sword::SWKey const *)arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__SWModule, 0 |  0 );
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SWText___lshift__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SWText___lshift__", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__SWText, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_sword__SWKey, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SWText___lshift____SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__SWText, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SWText___lshift____SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SWText___isub__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWText *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  sword::SWModule *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SWText___isub__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWText, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWText___isub__" "', argument " "1"" of type '" "sword::SWText *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWText * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SWText___isub__" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    try {
      result = (sword::SWModule *) &(arg1)->operator -=(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__SWModule, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWText___iadd__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWText *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  sword::SWModule *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SWText___iadd__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWText, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWText___iadd__" "', argument " "1"" of type '" "sword::SWText *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWText * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SWText___iadd__" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    try {
      result = (sword::SWModule *) &(arg1)->operator +=(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__SWModule, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWText_castTo(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWModule *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  sword::SWText *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWText_castTo" "', argument " "1"" of type '" "sword::SWModule *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWModule * >(argp1);
  {
    try {
      result = (sword::SWText *)sword_SWText_castTo(arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__SWText, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SWText_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_sword__SWText, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_RawText__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  char *arg2 = 0 ;
  char *arg3 = 0 ;
  sword::SWDisplay *arg4 = 0 ;
  char arg5 ;
  char arg6 ;
  char arg7 ;
  char *arg8 = 0 ;
  char *arg9 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  char val5 ;
  int ecode5 = 0 ;
  char val6 ;
  int ecode6 = 0 ;
  char val7 ;
  int ecode7 = 0 ;
  int res8 ;
  char *buf8 = 0 ;
  int alloc8 = 0 ;
  int res9 ;
  char *buf9 = 0 ;
  int alloc9 = 0 ;
  sword::RawText *result = 0 ;
  
  (void)self;
  if ((nobjs < 9) || (nobjs > 9)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_RawText" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_RawText" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_RawText" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_sword__SWDisplay, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_RawText" "', argument " "4"" of type '" "sword::SWDisplay *""'"); 
  }
  arg4 = reinterpret_cast< sword::SWDisplay * >(argp4);
  ecode5 = SWIG_AsVal_char(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_RawText" "', argument " "5"" of type '" "char""'");
  } 
  arg5 = static_cast< char >(val5);
  ecode6 = SWIG_AsVal_char(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_RawText" "', argument " "6"" of type '" "char""'");
  } 
  arg6 = static_cast< char >(val6);
  ecode7 = SWIG_AsVal_char(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_RawText" "', argument " "7"" of type '" "char""'");
  } 
  arg7 = static_cast< char >(val7);
  res8 = SWIG_AsCharPtrAndSize(swig_obj[7], &buf8, NULL, &alloc8);
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "new_RawText" "', argument " "8"" of type '" "char const *""'");
  }
  arg8 = reinterpret_cast< char * >(buf8);
  res9 = SWIG_AsCharPtrAndSize(swig_obj[8], &buf9, NULL, &alloc9);
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "new_RawText" "', argument " "9"" of type '" "char const *""'");
  }
  arg9 = reinterpret_cast< char * >(buf9);
  {
    try {
      result = (sword::RawText *)new sword::RawText((char const *)arg1,(char const *)arg2,(char const *)arg3,arg4,arg5,arg6,arg7,(char const *)arg8,(char const *)arg9); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__RawText, SWIG_POINTER_NEW |  0 );
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  if (alloc8 == SWIG_NEWOBJ) delete[] buf8;
  if (alloc9 == SWIG_NEWOBJ) delete[] buf9;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  if (alloc8 == SWIG_NEWOBJ) delete[] buf8;
  if (alloc9 == SWIG_NEWOBJ) delete[] buf9;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RawText__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  char *arg2 = 0 ;
  char *arg3 = 0 ;
  sword::SWDisplay *arg4 = 0 ;
  char arg5 ;
  char arg6 ;
  char arg7 ;
  char *arg8 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  char val5 ;
  int ecode5 = 0 ;
  char val6 ;
  int ecode6 = 0 ;
  char val7 ;
  int ecode7 = 0 ;
  int res8 ;
  char *buf8 = 0 ;
  int alloc8 = 0 ;
  sword::RawText *result = 0 ;
  
  (void)self;
  if ((nobjs < 8) || (nobjs > 8)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_RawText" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_RawText" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_RawText" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_sword__SWDisplay, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_RawText" "', argument " "4"" of type '" "sword::SWDisplay *""'"); 
  }
  arg4 = reinterpret_cast< sword::SWDisplay * >(argp4);
  ecode5 = SWIG_AsVal_char(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_RawText" "', argument " "5"" of type '" "char""'");
  } 
  arg5 = static_cast< char >(val5);
  ecode6 = SWIG_AsVal_char(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_RawText" "', argument " "6"" of type '" "char""'");
  } 
  arg6 = static_cast< char >(val6);
  ecode7 = SWIG_AsVal_char(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_RawText" "', argument " "7"" of type '" "char""'");
  } 
  arg7 = static_cast< char >(val7);
  res8 = SWIG_AsCharPtrAndSize(swig_obj[7], &buf8, NULL, &alloc8);
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "new_RawText" "', argument " "8"" of type '" "char const *""'");
  }
  arg8 = reinterpret_cast< char * >(buf8);
  {
    try {
      result = (sword::RawText *)new sword::RawText((char const *)arg1,(char const *)arg2,(char const *)arg3,arg4,arg5,arg6,arg7,(char const *)arg8); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__RawText, SWIG_POINTER_NEW |  0 );
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  if (alloc8 == SWIG_NEWOBJ) delete[] buf8;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  if (alloc8 == SWIG_NEWOBJ) delete[] buf8;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RawText__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  char *arg2 = 0 ;
  char *arg3 = 0 ;
  sword::SWDisplay *arg4 = 0 ;
  char arg5 ;
  char arg6 ;
  char arg7 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  char val5 ;
  int ecode5 = 0 ;
  char val6 ;
  int ecode6 = 0 ;
  char val7 ;
  int ecode7 = 0 ;
  sword::RawText *result = 0 ;
  
  (void)self;
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_RawText" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_RawText" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_RawText" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_sword__SWDisplay, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_RawText" "', argument " "4"" of type '" "sword::SWDisplay *""'"); 
  }
  arg4 = reinterpret_cast< sword::SWDisplay * >(argp4);
  ecode5 = SWIG_AsVal_char(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_RawText" "', argument " "5"" of type '" "char""'");
  } 
  arg5 = static_cast< char >(val5);
  ecode6 = SWIG_AsVal_char(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_RawText" "', argument " "6"" of type '" "char""'");
  } 
  arg6 = static_cast< char >(val6);
  ecode7 = SWIG_AsVal_char(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_RawText" "', argument " "7"" of type '" "char""'");
  } 
  arg7 = static_cast< char >(val7);
  {
    try {
      result = (sword::RawText *)new sword::RawText((char const *)arg1,(char const *)arg2,(char const *)arg3,arg4,arg5,arg6,arg7); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__RawText, SWIG_POINTER_NEW |  0 );
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RawText__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  char *arg2 = 0 ;
  char *arg3 = 0 ;
  sword::SWDisplay *arg4 = 0 ;
  char arg5 ;
  char arg6 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  char val5 ;
  int ecode5 = 0 ;
  char val6 ;
  int ecode6 = 0 ;
  sword::RawText *result = 0 ;
  
  (void)self;
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_RawText" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_RawText" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_RawText" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_sword__SWDisplay, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_RawText" "', argument " "4"" of type '" "sword::SWDisplay *""'"); 
  }
  arg4 = reinterpret_cast< sword::SWDisplay * >(argp4);
  ecode5 = SWIG_AsVal_char(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_RawText" "', argument " "5"" of type '" "char""'");
  } 
  arg5 = static_cast< char >(val5);
  ecode6 = SWIG_AsVal_char(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_RawText" "', argument " "6"" of type '" "char""'");
  } 
  arg6 = static_cast< char >(val6);
  {
    try {
      result = (sword::RawText *)new sword::RawText((char const *)arg1,(char const *)arg2,(char const *)arg3,arg4,arg5,arg6); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__RawText, SWIG_POINTER_NEW |  0 );
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RawText__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  char *arg2 = 0 ;
  char *arg3 = 0 ;
  sword::SWDisplay *arg4 = 0 ;
  char arg5 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  char val5 ;
  int ecode5 = 0 ;
  sword::RawText *result = 0 ;
  
  (void)self;
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_RawText" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_RawText" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_RawText" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_sword__SWDisplay, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_RawText" "', argument " "4"" of type '" "sword::SWDisplay *""'"); 
  }
  arg4 = reinterpret_cast< sword::SWDisplay * >(argp4);
  ecode5 = SWIG_AsVal_char(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_RawText" "', argument " "5"" of type '" "char""'");
  } 
  arg5 = static_cast< char >(val5);
  {
    try {
      result = (sword::RawText *)new sword::RawText((char const *)arg1,(char const *)arg2,(char const *)arg3,arg4,arg5); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__RawText, SWIG_POINTER_NEW |  0 );
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RawText__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  char *arg2 = 0 ;
  char *arg3 = 0 ;
  sword::SWDisplay *arg4 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  sword::RawText *result = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_RawText" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_RawText" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_RawText" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_sword__SWDisplay, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_RawText" "', argument " "4"" of type '" "sword::SWDisplay *""'"); 
  }
  arg4 = reinterpret_cast< sword::SWDisplay * >(argp4);
  {
    try {
      result = (sword::RawText *)new sword::RawText((char const *)arg1,(char const *)arg2,(char const *)arg3,arg4); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__RawText, SWIG_POINTER_NEW |  0 );
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RawText__SWIG_6(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  char *arg2 = 0 ;
  char *arg3 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  sword::RawText *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_RawText" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_RawText" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_RawText" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  {
    try {
      result = (sword::RawText *)new sword::RawText((char const *)arg1,(char const *)arg2,(char const *)arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__RawText, SWIG_POINTER_NEW |  0 );
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RawText__SWIG_7(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  char *arg2 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  sword::RawText *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_RawText" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_RawText" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    try {
      result = (sword::RawText *)new sword::RawText((char const *)arg1,(char const *)arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__RawText, SWIG_POINTER_NEW |  0 );
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RawText__SWIG_8(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  sword::RawText *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_RawText" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  {
    try {
      result = (sword::RawText *)new sword::RawText((char const *)arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__RawText, SWIG_POINTER_NEW |  0 );
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RawText(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[10] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_RawText", 0, 9, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_RawText__SWIG_8(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_RawText__SWIG_7(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_new_RawText__SWIG_6(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_sword__SWDisplay, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_new_RawText__SWIG_5(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_sword__SWDisplay, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_char(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_new_RawText__SWIG_4(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_sword__SWDisplay, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_char(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_char(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_new_RawText__SWIG_3(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v = 0;
    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_sword__SWDisplay, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_char(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_char(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_char(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_new_RawText__SWIG_2(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v = 0;
    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_sword__SWDisplay, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_char(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_char(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_char(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  int res = SWIG_AsCharPtrAndSize(argv[7], 0, NULL, 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    return _wrap_new_RawText__SWIG_1(self, argc, argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v = 0;
    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_sword__SWDisplay, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_char(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_char(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_char(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  int res = SWIG_AsCharPtrAndSize(argv[7], 0, NULL, 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    int res = SWIG_AsCharPtrAndSize(argv[8], 0, NULL, 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      return _wrap_new_RawText__SWIG_0(self, argc, argv);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_RawText'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    sword::RawText::RawText(char const *,char const *,char const *,sword::SWDisplay *,char,char,char,char const *,char const *)\n"
    "    sword::RawText::RawText(char const *,char const *,char const *,sword::SWDisplay *,char,char,char,char const *)\n"
    "    sword::RawText::RawText(char const *,char const *,char const *,sword::SWDisplay *,char,char,char)\n"
    "    sword::RawText::RawText(char const *,char const *,char const *,sword::SWDisplay *,char,char)\n"
    "    sword::RawText::RawText(char const *,char const *,char const *,sword::SWDisplay *,char)\n"
    "    sword::RawText::RawText(char const *,char const *,char const *,sword::SWDisplay *)\n"
    "    sword::RawText::RawText(char const *,char const *,char const *)\n"
    "    sword::RawText::RawText(char const *,char const *)\n"
    "    sword::RawText::RawText(char const *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_RawText(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::RawText *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__RawText, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RawText" "', argument " "1"" of type '" "sword::RawText *""'"); 
  }
  arg1 = reinterpret_cast< sword::RawText * >(argp1);
  {
    try {
      delete arg1; 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RawText_getRawEntryBuf(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::RawText *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  sword::SWBuf *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__RawText, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RawText_getRawEntryBuf" "', argument " "1"" of type '" "sword::RawText const *""'"); 
  }
  arg1 = reinterpret_cast< sword::RawText * >(argp1);
  {
    try {
      result = (sword::SWBuf *) &((sword::RawText const *)arg1)->getRawEntryBuf(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__SWBuf, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RawText_increment__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::RawText *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__RawText, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RawText_increment" "', argument " "1"" of type '" "sword::RawText *""'"); 
  }
  arg1 = reinterpret_cast< sword::RawText * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RawText_increment" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    try {
      (arg1)->increment(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RawText_increment__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::RawText *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__RawText, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RawText_increment" "', argument " "1"" of type '" "sword::RawText *""'"); 
  }
  arg1 = reinterpret_cast< sword::RawText * >(argp1);
  {
    try {
      (arg1)->increment(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RawText_increment(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "RawText_increment", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__RawText, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_RawText_increment__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__RawText, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_RawText_increment__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'RawText_increment'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    sword::RawText::increment(int)\n"
    "    sword::RawText::increment()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_RawText_decrement__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::RawText *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__RawText, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RawText_decrement" "', argument " "1"" of type '" "sword::RawText *""'"); 
  }
  arg1 = reinterpret_cast< sword::RawText * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RawText_decrement" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    try {
      (arg1)->decrement(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RawText_decrement__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::RawText *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__RawText, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RawText_decrement" "', argument " "1"" of type '" "sword::RawText *""'"); 
  }
  arg1 = reinterpret_cast< sword::RawText * >(argp1);
  {
    try {
      (arg1)->decrement(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RawText_decrement(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "RawText_decrement", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__RawText, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_RawText_decrement__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__RawText, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_RawText_decrement__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'RawText_decrement'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    sword::RawText::decrement(int)\n"
    "    sword::RawText::decrement()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_RawText_isWritable(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::RawText *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__RawText, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RawText_isWritable" "', argument " "1"" of type '" "sword::RawText const *""'"); 
  }
  arg1 = reinterpret_cast< sword::RawText * >(argp1);
  {
    try {
      result = (bool)((sword::RawText const *)arg1)->isWritable(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RawText_createModule__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  char *arg2 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  char result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RawText_createModule" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RawText_createModule" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    try {
      result = (char)sword::RawText::createModule((char const *)arg1,(char const *)arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_char(static_cast< char >(result));
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_RawText_createModule__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  char result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RawText_createModule" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  {
    try {
      result = (char)sword::RawText::createModule((char const *)arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_char(static_cast< char >(result));
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_RawText_createModule(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "RawText_createModule", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_RawText_createModule__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_RawText_createModule__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'RawText_createModule'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    sword::RawText::createModule(char const *,char const *)\n"
    "    sword::RawText::createModule(char const *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_RawText_setEntry__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::RawText *arg1 = 0 ;
  char *arg2 = 0 ;
  long arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  long val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__RawText, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RawText_setEntry" "', argument " "1"" of type '" "sword::RawText *""'"); 
  }
  arg1 = reinterpret_cast< sword::RawText * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RawText_setEntry" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  ecode3 = SWIG_AsVal_long(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RawText_setEntry" "', argument " "3"" of type '" "long""'");
  } 
  arg3 = static_cast< long >(val3);
  {
    try {
      (arg1)->setEntry((char const *)arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_RawText_setEntry__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::RawText *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__RawText, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RawText_setEntry" "', argument " "1"" of type '" "sword::RawText *""'"); 
  }
  arg1 = reinterpret_cast< sword::RawText * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RawText_setEntry" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    try {
      (arg1)->setEntry((char const *)arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_RawText_setEntry(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "RawText_setEntry", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__RawText, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_RawText_setEntry__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__RawText, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_long(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_RawText_setEntry__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'RawText_setEntry'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    sword::RawText::setEntry(char const *,long)\n"
    "    sword::RawText::setEntry(char const *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_RawText_linkEntry(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::RawText *arg1 = 0 ;
  sword::SWKey *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "RawText_linkEntry", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__RawText, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RawText_linkEntry" "', argument " "1"" of type '" "sword::RawText *""'"); 
  }
  arg1 = reinterpret_cast< sword::RawText * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_sword__SWKey, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RawText_linkEntry" "', argument " "2"" of type '" "sword::SWKey const *""'"); 
  }
  arg2 = reinterpret_cast< sword::SWKey * >(argp2);
  {
    try {
      (arg1)->linkEntry((sword::SWKey const *)arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RawText_deleteEntry(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::RawText *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__RawText, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RawText_deleteEntry" "', argument " "1"" of type '" "sword::RawText *""'"); 
  }
  arg1 = reinterpret_cast< sword::RawText * >(argp1);
  {
    try {
      (arg1)->deleteEntry(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RawText_isLinked(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::RawText *arg1 = 0 ;
  sword::SWKey *arg2 = 0 ;
  sword::SWKey *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "RawText_isLinked", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__RawText, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RawText_isLinked" "', argument " "1"" of type '" "sword::RawText const *""'"); 
  }
  arg1 = reinterpret_cast< sword::RawText * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_sword__SWKey, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RawText_isLinked" "', argument " "2"" of type '" "sword::SWKey const *""'"); 
  }
  arg2 = reinterpret_cast< sword::SWKey * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_sword__SWKey, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RawText_isLinked" "', argument " "3"" of type '" "sword::SWKey const *""'"); 
  }
  arg3 = reinterpret_cast< sword::SWKey * >(argp3);
  {
    try {
      result = (bool)((sword::RawText const *)arg1)->isLinked((sword::SWKey const *)arg2,(sword::SWKey const *)arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RawText_hasEntry(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::RawText *arg1 = 0 ;
  sword::SWKey *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "RawText_hasEntry", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__RawText, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RawText_hasEntry" "', argument " "1"" of type '" "sword::RawText const *""'"); 
  }
  arg1 = reinterpret_cast< sword::RawText * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_sword__SWKey, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RawText_hasEntry" "', argument " "2"" of type '" "sword::SWKey const *""'"); 
  }
  arg2 = reinterpret_cast< sword::SWKey * >(argp2);
  {
    try {
      result = (bool)((sword::RawText const *)arg1)->hasEntry((sword::SWKey const *)arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RawText___lshift____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::RawText *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  sword::SWModule *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__RawText, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RawText___lshift__" "', argument " "1"" of type '" "sword::RawText *""'"); 
  }
  arg1 = reinterpret_cast< sword::RawText * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RawText___lshift__" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    try {
      result = (sword::SWModule *) &(arg1)->operator <<((char const *)arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__SWModule, 0 |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_RawText___lshift____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::RawText *arg1 = 0 ;
  sword::SWKey *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  sword::SWModule *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__RawText, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RawText___lshift__" "', argument " "1"" of type '" "sword::RawText *""'"); 
  }
  arg1 = reinterpret_cast< sword::RawText * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_sword__SWKey, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RawText___lshift__" "', argument " "2"" of type '" "sword::SWKey const *""'"); 
  }
  arg2 = reinterpret_cast< sword::SWKey * >(argp2);
  {
    try {
      result = (sword::SWModule *) &(arg1)->operator <<((sword::SWKey const *)arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__SWModule, 0 |  0 );
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_RawText___lshift__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "RawText___lshift__", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__RawText, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_sword__SWKey, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_RawText___lshift____SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__RawText, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_RawText___lshift____SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_RawText___isub__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::RawText *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  sword::SWModule *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "RawText___isub__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__RawText, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RawText___isub__" "', argument " "1"" of type '" "sword::RawText *""'"); 
  }
  arg1 = reinterpret_cast< sword::RawText * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RawText___isub__" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    try {
      result = (sword::SWModule *) &(arg1)->operator -=(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__SWModule, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RawText___iadd__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::RawText *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  sword::SWModule *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "RawText___iadd__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__RawText, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RawText___iadd__" "', argument " "1"" of type '" "sword::RawText *""'"); 
  }
  arg1 = reinterpret_cast< sword::RawText * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RawText___iadd__" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    try {
      result = (sword::SWModule *) &(arg1)->operator +=(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__SWModule, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RawText_castTo(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWModule *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  sword::RawText *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RawText_castTo" "', argument " "1"" of type '" "sword::SWModule *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWModule * >(argp1);
  {
    try {
      result = (sword::RawText *)sword_RawText_castTo(arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__RawText, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *RawText_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_sword__RawText, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *RawText_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_zText__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  char *arg2 = 0 ;
  char *arg3 = 0 ;
  int arg4 ;
  sword::SWCompress *arg5 = 0 ;
  sword::SWDisplay *arg6 = 0 ;
  char arg7 ;
  char arg8 ;
  char arg9 ;
  char *arg10 = 0 ;
  char *arg11 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  char val7 ;
  int ecode7 = 0 ;
  char val8 ;
  int ecode8 = 0 ;
  char val9 ;
  int ecode9 = 0 ;
  int res10 ;
  char *buf10 = 0 ;
  int alloc10 = 0 ;
  int res11 ;
  char *buf11 = 0 ;
  int alloc11 = 0 ;
  sword::zText *result = 0 ;
  
  (void)self;
  if ((nobjs < 11) || (nobjs > 11)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_zText" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_zText" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_zText" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_zText" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5,SWIGTYPE_p_sword__SWCompress, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_zText" "', argument " "5"" of type '" "sword::SWCompress *""'"); 
  }
  arg5 = reinterpret_cast< sword::SWCompress * >(argp5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6,SWIGTYPE_p_sword__SWDisplay, 0 |  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_zText" "', argument " "6"" of type '" "sword::SWDisplay *""'"); 
  }
  arg6 = reinterpret_cast< sword::SWDisplay * >(argp6);
  ecode7 = SWIG_AsVal_char(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_zText" "', argument " "7"" of type '" "char""'");
  } 
  arg7 = static_cast< char >(val7);
  ecode8 = SWIG_AsVal_char(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_zText" "', argument " "8"" of type '" "char""'");
  } 
  arg8 = static_cast< char >(val8);
  ecode9 = SWIG_AsVal_char(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_zText" "', argument " "9"" of type '" "char""'");
  } 
  arg9 = static_cast< char >(val9);
  res10 = SWIG_AsCharPtrAndSize(swig_obj[9], &buf10, NULL, &alloc10);
  if (!SWIG_IsOK(res10)) {
    SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "new_zText" "', argument " "10"" of type '" "char const *""'");
  }
  arg10 = reinterpret_cast< char * >(buf10);
  res11 = SWIG_AsCharPtrAndSize(swig_obj[10], &buf11, NULL, &alloc11);
  if (!SWIG_IsOK(res11)) {
    SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "new_zText" "', argument " "11"" of type '" "char const *""'");
  }
  arg11 = reinterpret_cast< char * >(buf11);
  {
    try {
      result = (sword::zText *)new sword::zText((char const *)arg1,(char const *)arg2,(char const *)arg3,arg4,arg5,arg6,arg7,arg8,arg9,(char const *)arg10,(char const *)arg11); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__zText, SWIG_POINTER_NEW |  0 );
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  if (alloc10 == SWIG_NEWOBJ) delete[] buf10;
  if (alloc11 == SWIG_NEWOBJ) delete[] buf11;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  if (alloc10 == SWIG_NEWOBJ) delete[] buf10;
  if (alloc11 == SWIG_NEWOBJ) delete[] buf11;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_zText__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  char *arg2 = 0 ;
  char *arg3 = 0 ;
  int arg4 ;
  sword::SWCompress *arg5 = 0 ;
  sword::SWDisplay *arg6 = 0 ;
  char arg7 ;
  char arg8 ;
  char arg9 ;
  char *arg10 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  char val7 ;
  int ecode7 = 0 ;
  char val8 ;
  int ecode8 = 0 ;
  char val9 ;
  int ecode9 = 0 ;
  int res10 ;
  char *buf10 = 0 ;
  int alloc10 = 0 ;
  sword::zText *result = 0 ;
  
  (void)self;
  if ((nobjs < 10) || (nobjs > 10)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_zText" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_zText" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_zText" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_zText" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5,SWIGTYPE_p_sword__SWCompress, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_zText" "', argument " "5"" of type '" "sword::SWCompress *""'"); 
  }
  arg5 = reinterpret_cast< sword::SWCompress * >(argp5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6,SWIGTYPE_p_sword__SWDisplay, 0 |  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_zText" "', argument " "6"" of type '" "sword::SWDisplay *""'"); 
  }
  arg6 = reinterpret_cast< sword::SWDisplay * >(argp6);
  ecode7 = SWIG_AsVal_char(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_zText" "', argument " "7"" of type '" "char""'");
  } 
  arg7 = static_cast< char >(val7);
  ecode8 = SWIG_AsVal_char(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_zText" "', argument " "8"" of type '" "char""'");
  } 
  arg8 = static_cast< char >(val8);
  ecode9 = SWIG_AsVal_char(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_zText" "', argument " "9"" of type '" "char""'");
  } 
  arg9 = static_cast< char >(val9);
  res10 = SWIG_AsCharPtrAndSize(swig_obj[9], &buf10, NULL, &alloc10);
  if (!SWIG_IsOK(res10)) {
    SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "new_zText" "', argument " "10"" of type '" "char const *""'");
  }
  arg10 = reinterpret_cast< char * >(buf10);
  {
    try {
      result = (sword::zText *)new sword::zText((char const *)arg1,(char const *)arg2,(char const *)arg3,arg4,arg5,arg6,arg7,arg8,arg9,(char const *)arg10); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__zText, SWIG_POINTER_NEW |  0 );
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  if (alloc10 == SWIG_NEWOBJ) delete[] buf10;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  if (alloc10 == SWIG_NEWOBJ) delete[] buf10;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_zText__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  char *arg2 = 0 ;
  char *arg3 = 0 ;
  int arg4 ;
  sword::SWCompress *arg5 = 0 ;
  sword::SWDisplay *arg6 = 0 ;
  char arg7 ;
  char arg8 ;
  char arg9 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  char val7 ;
  int ecode7 = 0 ;
  char val8 ;
  int ecode8 = 0 ;
  char val9 ;
  int ecode9 = 0 ;
  sword::zText *result = 0 ;
  
  (void)self;
  if ((nobjs < 9) || (nobjs > 9)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_zText" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_zText" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_zText" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_zText" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5,SWIGTYPE_p_sword__SWCompress, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_zText" "', argument " "5"" of type '" "sword::SWCompress *""'"); 
  }
  arg5 = reinterpret_cast< sword::SWCompress * >(argp5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6,SWIGTYPE_p_sword__SWDisplay, 0 |  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_zText" "', argument " "6"" of type '" "sword::SWDisplay *""'"); 
  }
  arg6 = reinterpret_cast< sword::SWDisplay * >(argp6);
  ecode7 = SWIG_AsVal_char(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_zText" "', argument " "7"" of type '" "char""'");
  } 
  arg7 = static_cast< char >(val7);
  ecode8 = SWIG_AsVal_char(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_zText" "', argument " "8"" of type '" "char""'");
  } 
  arg8 = static_cast< char >(val8);
  ecode9 = SWIG_AsVal_char(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_zText" "', argument " "9"" of type '" "char""'");
  } 
  arg9 = static_cast< char >(val9);
  {
    try {
      result = (sword::zText *)new sword::zText((char const *)arg1,(char const *)arg2,(char const *)arg3,arg4,arg5,arg6,arg7,arg8,arg9); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__zText, SWIG_POINTER_NEW |  0 );
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_zText__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  char *arg2 = 0 ;
  char *arg3 = 0 ;
  int arg4 ;
  sword::SWCompress *arg5 = 0 ;
  sword::SWDisplay *arg6 = 0 ;
  char arg7 ;
  char arg8 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  char val7 ;
  int ecode7 = 0 ;
  char val8 ;
  int ecode8 = 0 ;
  sword::zText *result = 0 ;
  
  (void)self;
  if ((nobjs < 8) || (nobjs > 8)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_zText" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_zText" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_zText" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_zText" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5,SWIGTYPE_p_sword__SWCompress, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_zText" "', argument " "5"" of type '" "sword::SWCompress *""'"); 
  }
  arg5 = reinterpret_cast< sword::SWCompress * >(argp5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6,SWIGTYPE_p_sword__SWDisplay, 0 |  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_zText" "', argument " "6"" of type '" "sword::SWDisplay *""'"); 
  }
  arg6 = reinterpret_cast< sword::SWDisplay * >(argp6);
  ecode7 = SWIG_AsVal_char(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_zText" "', argument " "7"" of type '" "char""'");
  } 
  arg7 = static_cast< char >(val7);
  ecode8 = SWIG_AsVal_char(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_zText" "', argument " "8"" of type '" "char""'");
  } 
  arg8 = static_cast< char >(val8);
  {
    try {
      result = (sword::zText *)new sword::zText((char const *)arg1,(char const *)arg2,(char const *)arg3,arg4,arg5,arg6,arg7,arg8); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__zText, SWIG_POINTER_NEW |  0 );
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_zText__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  char *arg2 = 0 ;
  char *arg3 = 0 ;
  int arg4 ;
  sword::SWCompress *arg5 = 0 ;
  sword::SWDisplay *arg6 = 0 ;
  char arg7 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  char val7 ;
  int ecode7 = 0 ;
  sword::zText *result = 0 ;
  
  (void)self;
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_zText" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_zText" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_zText" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_zText" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5,SWIGTYPE_p_sword__SWCompress, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_zText" "', argument " "5"" of type '" "sword::SWCompress *""'"); 
  }
  arg5 = reinterpret_cast< sword::SWCompress * >(argp5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6,SWIGTYPE_p_sword__SWDisplay, 0 |  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_zText" "', argument " "6"" of type '" "sword::SWDisplay *""'"); 
  }
  arg6 = reinterpret_cast< sword::SWDisplay * >(argp6);
  ecode7 = SWIG_AsVal_char(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_zText" "', argument " "7"" of type '" "char""'");
  } 
  arg7 = static_cast< char >(val7);
  {
    try {
      result = (sword::zText *)new sword::zText((char const *)arg1,(char const *)arg2,(char const *)arg3,arg4,arg5,arg6,arg7); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__zText, SWIG_POINTER_NEW |  0 );
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_zText__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  char *arg2 = 0 ;
  char *arg3 = 0 ;
  int arg4 ;
  sword::SWCompress *arg5 = 0 ;
  sword::SWDisplay *arg6 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  sword::zText *result = 0 ;
  
  (void)self;
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_zText" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_zText" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_zText" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_zText" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5,SWIGTYPE_p_sword__SWCompress, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_zText" "', argument " "5"" of type '" "sword::SWCompress *""'"); 
  }
  arg5 = reinterpret_cast< sword::SWCompress * >(argp5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6,SWIGTYPE_p_sword__SWDisplay, 0 |  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_zText" "', argument " "6"" of type '" "sword::SWDisplay *""'"); 
  }
  arg6 = reinterpret_cast< sword::SWDisplay * >(argp6);
  {
    try {
      result = (sword::zText *)new sword::zText((char const *)arg1,(char const *)arg2,(char const *)arg3,arg4,arg5,arg6); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__zText, SWIG_POINTER_NEW |  0 );
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_zText__SWIG_6(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  char *arg2 = 0 ;
  char *arg3 = 0 ;
  int arg4 ;
  sword::SWCompress *arg5 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  sword::zText *result = 0 ;
  
  (void)self;
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_zText" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_zText" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_zText" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_zText" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5,SWIGTYPE_p_sword__SWCompress, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_zText" "', argument " "5"" of type '" "sword::SWCompress *""'"); 
  }
  arg5 = reinterpret_cast< sword::SWCompress * >(argp5);
  {
    try {
      result = (sword::zText *)new sword::zText((char const *)arg1,(char const *)arg2,(char const *)arg3,arg4,arg5); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__zText, SWIG_POINTER_NEW |  0 );
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_zText__SWIG_7(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  char *arg2 = 0 ;
  char *arg3 = 0 ;
  int arg4 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  sword::zText *result = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_zText" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_zText" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_zText" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_zText" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  {
    try {
      result = (sword::zText *)new sword::zText((char const *)arg1,(char const *)arg2,(char const *)arg3,arg4); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__zText, SWIG_POINTER_NEW |  0 );
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_zText__SWIG_8(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  char *arg2 = 0 ;
  char *arg3 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  sword::zText *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_zText" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_zText" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_zText" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  {
    try {
      result = (sword::zText *)new sword::zText((char const *)arg1,(char const *)arg2,(char const *)arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__zText, SWIG_POINTER_NEW |  0 );
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_zText__SWIG_9(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  char *arg2 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  sword::zText *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_zText" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_zText" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    try {
      result = (sword::zText *)new sword::zText((char const *)arg1,(char const *)arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__zText, SWIG_POINTER_NEW |  0 );
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_zText__SWIG_10(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  sword::zText *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_zText" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  {
    try {
      result = (sword::zText *)new sword::zText((char const *)arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__zText, SWIG_POINTER_NEW |  0 );
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_zText(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[12] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_zText", 0, 11, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_zText__SWIG_10(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_zText__SWIG_9(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_new_zText__SWIG_8(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_new_zText__SWIG_7(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_sword__SWCompress, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_new_zText__SWIG_6(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_sword__SWCompress, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_sword__SWDisplay, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                return _wrap_new_zText__SWIG_5(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v = 0;
    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_sword__SWCompress, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_sword__SWDisplay, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_char(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_new_zText__SWIG_4(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v = 0;
    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_sword__SWCompress, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_sword__SWDisplay, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_char(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_char(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    return _wrap_new_zText__SWIG_3(self, argc, argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v = 0;
    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_sword__SWCompress, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_sword__SWDisplay, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_char(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_char(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_char(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      return _wrap_new_zText__SWIG_2(self, argc, argv);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 10) {
    int _v = 0;
    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_sword__SWCompress, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_sword__SWDisplay, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_char(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_char(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_char(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      int res = SWIG_AsCharPtrAndSize(argv[9], 0, NULL, 0);
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        return _wrap_new_zText__SWIG_1(self, argc, argv);
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 11) {
    int _v = 0;
    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_sword__SWCompress, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_sword__SWDisplay, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_char(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_char(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_char(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      int res = SWIG_AsCharPtrAndSize(argv[9], 0, NULL, 0);
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        int res = SWIG_AsCharPtrAndSize(argv[10], 0, NULL, 0);
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          return _wrap_new_zText__SWIG_0(self, argc, argv);
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_zText'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    sword::zText::zText(char const *,char const *,char const *,int,sword::SWCompress *,sword::SWDisplay *,char,char,char,char const *,char const *)\n"
    "    sword::zText::zText(char const *,char const *,char const *,int,sword::SWCompress *,sword::SWDisplay *,char,char,char,char const *)\n"
    "    sword::zText::zText(char const *,char const *,char const *,int,sword::SWCompress *,sword::SWDisplay *,char,char,char)\n"
    "    sword::zText::zText(char const *,char const *,char const *,int,sword::SWCompress *,sword::SWDisplay *,char,char)\n"
    "    sword::zText::zText(char const *,char const *,char const *,int,sword::SWCompress *,sword::SWDisplay *,char)\n"
    "    sword::zText::zText(char const *,char const *,char const *,int,sword::SWCompress *,sword::SWDisplay *)\n"
    "    sword::zText::zText(char const *,char const *,char const *,int,sword::SWCompress *)\n"
    "    sword::zText::zText(char const *,char const *,char const *,int)\n"
    "    sword::zText::zText(char const *,char const *,char const *)\n"
    "    sword::zText::zText(char const *,char const *)\n"
    "    sword::zText::zText(char const *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_zText(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::zText *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__zText, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_zText" "', argument " "1"" of type '" "sword::zText *""'"); 
  }
  arg1 = reinterpret_cast< sword::zText * >(argp1);
  {
    try {
      delete arg1; 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_zText_getRawEntryBuf(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::zText *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  sword::SWBuf *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__zText, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "zText_getRawEntryBuf" "', argument " "1"" of type '" "sword::zText const *""'"); 
  }
  arg1 = reinterpret_cast< sword::zText * >(argp1);
  {
    try {
      result = (sword::SWBuf *) &((sword::zText const *)arg1)->getRawEntryBuf(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__SWBuf, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_zText_increment__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::zText *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__zText, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "zText_increment" "', argument " "1"" of type '" "sword::zText *""'"); 
  }
  arg1 = reinterpret_cast< sword::zText * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "zText_increment" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    try {
      (arg1)->increment(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_zText_increment__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::zText *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__zText, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "zText_increment" "', argument " "1"" of type '" "sword::zText *""'"); 
  }
  arg1 = reinterpret_cast< sword::zText * >(argp1);
  {
    try {
      (arg1)->increment(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_zText_increment(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "zText_increment", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__zText, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_zText_increment__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__zText, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_zText_increment__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'zText_increment'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    sword::zText::increment(int)\n"
    "    sword::zText::increment()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_zText_decrement__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::zText *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__zText, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "zText_decrement" "', argument " "1"" of type '" "sword::zText *""'"); 
  }
  arg1 = reinterpret_cast< sword::zText * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "zText_decrement" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    try {
      (arg1)->decrement(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_zText_decrement__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::zText *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__zText, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "zText_decrement" "', argument " "1"" of type '" "sword::zText *""'"); 
  }
  arg1 = reinterpret_cast< sword::zText * >(argp1);
  {
    try {
      (arg1)->decrement(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_zText_decrement(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "zText_decrement", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__zText, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_zText_decrement__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__zText, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_zText_decrement__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'zText_decrement'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    sword::zText::decrement(int)\n"
    "    sword::zText::decrement()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_zText_isWritable(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::zText *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__zText, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "zText_isWritable" "', argument " "1"" of type '" "sword::zText const *""'"); 
  }
  arg1 = reinterpret_cast< sword::zText * >(argp1);
  {
    try {
      result = (bool)((sword::zText const *)arg1)->isWritable(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_zText_createModule__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  int arg2 ;
  char *arg3 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  char result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "zText_createModule" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "zText_createModule" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "zText_createModule" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  {
    try {
      result = (char)sword::zText::createModule((char const *)arg1,arg2,(char const *)arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_char(static_cast< char >(result));
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_zText_createModule__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  int arg2 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  char result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "zText_createModule" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "zText_createModule" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    try {
      result = (char)sword::zText::createModule((char const *)arg1,arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_char(static_cast< char >(result));
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_zText_createModule(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "zText_createModule", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_zText_createModule__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_zText_createModule__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'zText_createModule'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    sword::zText::createModule(char const *,int,char const *)\n"
    "    sword::zText::createModule(char const *,int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_zText_setEntry__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::zText *arg1 = 0 ;
  char *arg2 = 0 ;
  long arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  long val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__zText, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "zText_setEntry" "', argument " "1"" of type '" "sword::zText *""'"); 
  }
  arg1 = reinterpret_cast< sword::zText * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "zText_setEntry" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  ecode3 = SWIG_AsVal_long(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "zText_setEntry" "', argument " "3"" of type '" "long""'");
  } 
  arg3 = static_cast< long >(val3);
  {
    try {
      (arg1)->setEntry((char const *)arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_zText_setEntry__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::zText *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__zText, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "zText_setEntry" "', argument " "1"" of type '" "sword::zText *""'"); 
  }
  arg1 = reinterpret_cast< sword::zText * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "zText_setEntry" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    try {
      (arg1)->setEntry((char const *)arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_zText_setEntry(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "zText_setEntry", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__zText, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_zText_setEntry__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__zText, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_long(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_zText_setEntry__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'zText_setEntry'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    sword::zText::setEntry(char const *,long)\n"
    "    sword::zText::setEntry(char const *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_zText_linkEntry(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::zText *arg1 = 0 ;
  sword::SWKey *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "zText_linkEntry", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__zText, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "zText_linkEntry" "', argument " "1"" of type '" "sword::zText *""'"); 
  }
  arg1 = reinterpret_cast< sword::zText * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_sword__SWKey, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "zText_linkEntry" "', argument " "2"" of type '" "sword::SWKey const *""'"); 
  }
  arg2 = reinterpret_cast< sword::SWKey * >(argp2);
  {
    try {
      (arg1)->linkEntry((sword::SWKey const *)arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_zText_deleteEntry(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::zText *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__zText, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "zText_deleteEntry" "', argument " "1"" of type '" "sword::zText *""'"); 
  }
  arg1 = reinterpret_cast< sword::zText * >(argp1);
  {
    try {
      (arg1)->deleteEntry(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_zText_rawZFilter__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::zText *arg1 = 0 ;
  sword::SWBuf *arg2 = 0 ;
  char arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  char val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__zText, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "zText_rawZFilter" "', argument " "1"" of type '" "sword::zText const *""'"); 
  }
  arg1 = reinterpret_cast< sword::zText * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_sword__SWBuf,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "zText_rawZFilter" "', argument " "2"" of type '" "sword::SWBuf &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "zText_rawZFilter" "', argument " "2"" of type '" "sword::SWBuf &""'"); 
  }
  arg2 = reinterpret_cast< sword::SWBuf * >(argp2);
  ecode3 = SWIG_AsVal_char(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "zText_rawZFilter" "', argument " "3"" of type '" "char""'");
  } 
  arg3 = static_cast< char >(val3);
  {
    try {
      ((sword::zText const *)arg1)->rawZFilter(*arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_zText_rawZFilter__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::zText *arg1 = 0 ;
  sword::SWBuf *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__zText, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "zText_rawZFilter" "', argument " "1"" of type '" "sword::zText const *""'"); 
  }
  arg1 = reinterpret_cast< sword::zText * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_sword__SWBuf,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "zText_rawZFilter" "', argument " "2"" of type '" "sword::SWBuf &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "zText_rawZFilter" "', argument " "2"" of type '" "sword::SWBuf &""'"); 
  }
  arg2 = reinterpret_cast< sword::SWBuf * >(argp2);
  {
    try {
      ((sword::zText const *)arg1)->rawZFilter(*arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_zText_rawZFilter(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "zText_rawZFilter", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__zText, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_sword__SWBuf, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_zText_rawZFilter__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__zText, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_sword__SWBuf, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_char(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_zText_rawZFilter__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'zText_rawZFilter'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    sword::zText::rawZFilter(sword::SWBuf &,char) const\n"
    "    sword::zText::rawZFilter(sword::SWBuf &) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_zText_flush(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::zText *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__zText, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "zText_flush" "', argument " "1"" of type '" "sword::zText *""'"); 
  }
  arg1 = reinterpret_cast< sword::zText * >(argp1);
  {
    try {
      (arg1)->flush(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_zText_isLinked(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::zText *arg1 = 0 ;
  sword::SWKey *arg2 = 0 ;
  sword::SWKey *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "zText_isLinked", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__zText, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "zText_isLinked" "', argument " "1"" of type '" "sword::zText const *""'"); 
  }
  arg1 = reinterpret_cast< sword::zText * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_sword__SWKey, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "zText_isLinked" "', argument " "2"" of type '" "sword::SWKey const *""'"); 
  }
  arg2 = reinterpret_cast< sword::SWKey * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_sword__SWKey, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "zText_isLinked" "', argument " "3"" of type '" "sword::SWKey const *""'"); 
  }
  arg3 = reinterpret_cast< sword::SWKey * >(argp3);
  {
    try {
      result = (bool)((sword::zText const *)arg1)->isLinked((sword::SWKey const *)arg2,(sword::SWKey const *)arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_zText_hasEntry(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::zText *arg1 = 0 ;
  sword::SWKey *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "zText_hasEntry", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__zText, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "zText_hasEntry" "', argument " "1"" of type '" "sword::zText const *""'"); 
  }
  arg1 = reinterpret_cast< sword::zText * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_sword__SWKey, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "zText_hasEntry" "', argument " "2"" of type '" "sword::SWKey const *""'"); 
  }
  arg2 = reinterpret_cast< sword::SWKey * >(argp2);
  {
    try {
      result = (bool)((sword::zText const *)arg1)->hasEntry((sword::SWKey const *)arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_zText___lshift____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::zText *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  sword::SWModule *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__zText, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "zText___lshift__" "', argument " "1"" of type '" "sword::zText *""'"); 
  }
  arg1 = reinterpret_cast< sword::zText * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "zText___lshift__" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    try {
      result = (sword::SWModule *) &(arg1)->operator <<((char const *)arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__SWModule, 0 |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_zText___lshift____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::zText *arg1 = 0 ;
  sword::SWKey *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  sword::SWModule *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__zText, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "zText___lshift__" "', argument " "1"" of type '" "sword::zText *""'"); 
  }
  arg1 = reinterpret_cast< sword::zText * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_sword__SWKey, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "zText___lshift__" "', argument " "2"" of type '" "sword::SWKey const *""'"); 
  }
  arg2 = reinterpret_cast< sword::SWKey * >(argp2);
  {
    try {
      result = (sword::SWModule *) &(arg1)->operator <<((sword::SWKey const *)arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__SWModule, 0 |  0 );
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_zText___lshift__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "zText___lshift__", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__zText, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_sword__SWKey, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_zText___lshift____SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__zText, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_zText___lshift____SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_zText___isub__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::zText *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  sword::SWModule *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "zText___isub__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__zText, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "zText___isub__" "', argument " "1"" of type '" "sword::zText *""'"); 
  }
  arg1 = reinterpret_cast< sword::zText * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "zText___isub__" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    try {
      result = (sword::SWModule *) &(arg1)->operator -=(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__SWModule, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_zText___iadd__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::zText *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  sword::SWModule *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "zText___iadd__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__zText, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "zText___iadd__" "', argument " "1"" of type '" "sword::zText *""'"); 
  }
  arg1 = reinterpret_cast< sword::zText * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "zText___iadd__" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    try {
      result = (sword::SWModule *) &(arg1)->operator +=(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__SWModule, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_zText_castTo(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWModule *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  sword::zText *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "zText_castTo" "', argument " "1"" of type '" "sword::SWModule *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWModule * >(argp1);
  {
    try {
      result = (sword::zText *)sword_zText_castTo(arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__zText, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *zText_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_sword__zText, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *zText_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_LocaleMgr__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  sword::LocaleMgr *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LocaleMgr" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  {
    try {
      result = (sword::LocaleMgr *)new sword::LocaleMgr((char const *)arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__LocaleMgr, SWIG_POINTER_NEW |  0 );
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LocaleMgr__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  sword::LocaleMgr *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (sword::LocaleMgr *)new sword::LocaleMgr(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__LocaleMgr, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LocaleMgr(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_LocaleMgr", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_LocaleMgr__SWIG_1(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LocaleMgr__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_LocaleMgr'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    sword::LocaleMgr::LocaleMgr(char const *)\n"
    "    sword::LocaleMgr::LocaleMgr()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_LocaleMgr(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::LocaleMgr *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__LocaleMgr, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LocaleMgr" "', argument " "1"" of type '" "sword::LocaleMgr *""'"); 
  }
  arg1 = reinterpret_cast< sword::LocaleMgr * >(argp1);
  {
    try {
      delete arg1; 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LocaleMgr_getLocale(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::LocaleMgr *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  sword::SWLocale *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "LocaleMgr_getLocale", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__LocaleMgr, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LocaleMgr_getLocale" "', argument " "1"" of type '" "sword::LocaleMgr *""'"); 
  }
  arg1 = reinterpret_cast< sword::LocaleMgr * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LocaleMgr_getLocale" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    try {
      result = (sword::SWLocale *)(arg1)->getLocale((char const *)arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__SWLocale, 0 |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_LocaleMgr_getAvailableLocales(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::LocaleMgr *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  sword::StringList result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__LocaleMgr, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LocaleMgr_getAvailableLocales" "', argument " "1"" of type '" "sword::LocaleMgr *""'"); 
  }
  arg1 = reinterpret_cast< sword::LocaleMgr * >(argp1);
  {
    try {
      result = (arg1)->getAvailableLocales(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = swig::from(static_cast< std::list< sword::SWBuf,std::allocator< sword::SWBuf > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LocaleMgr_translate__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::LocaleMgr *arg1 = 0 ;
  char *arg2 = 0 ;
  char *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  char *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__LocaleMgr, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LocaleMgr_translate" "', argument " "1"" of type '" "sword::LocaleMgr *""'"); 
  }
  arg1 = reinterpret_cast< sword::LocaleMgr * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LocaleMgr_translate" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "LocaleMgr_translate" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  {
    try {
      result = (char *)(arg1)->translate((char const *)arg2,(char const *)arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_LocaleMgr_translate__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::LocaleMgr *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  char *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__LocaleMgr, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LocaleMgr_translate" "', argument " "1"" of type '" "sword::LocaleMgr *""'"); 
  }
  arg1 = reinterpret_cast< sword::LocaleMgr * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LocaleMgr_translate" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    try {
      result = (char *)(arg1)->translate((char const *)arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_LocaleMgr_translate(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "LocaleMgr_translate", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__LocaleMgr, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_LocaleMgr_translate__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__LocaleMgr, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_LocaleMgr_translate__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'LocaleMgr_translate'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    sword::LocaleMgr::translate(char const *,char const *)\n"
    "    sword::LocaleMgr::translate(char const *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_LocaleMgr_getDefaultLocaleName(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::LocaleMgr *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__LocaleMgr, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LocaleMgr_getDefaultLocaleName" "', argument " "1"" of type '" "sword::LocaleMgr *""'"); 
  }
  arg1 = reinterpret_cast< sword::LocaleMgr * >(argp1);
  {
    try {
      result = (char *)(arg1)->getDefaultLocaleName(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LocaleMgr_setDefaultLocaleName(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::LocaleMgr *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "LocaleMgr_setDefaultLocaleName", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__LocaleMgr, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LocaleMgr_setDefaultLocaleName" "', argument " "1"" of type '" "sword::LocaleMgr *""'"); 
  }
  arg1 = reinterpret_cast< sword::LocaleMgr * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LocaleMgr_setDefaultLocaleName" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    try {
      (arg1)->setDefaultLocaleName((char const *)arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_LocaleMgr_getSystemLocaleMgr(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::LocaleMgr *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "LocaleMgr_getSystemLocaleMgr", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (sword::LocaleMgr *)sword::LocaleMgr::getSystemLocaleMgr(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__LocaleMgr, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LocaleMgr_setSystemLocaleMgr(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::LocaleMgr *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__LocaleMgr, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LocaleMgr_setSystemLocaleMgr" "', argument " "1"" of type '" "sword::LocaleMgr *""'"); 
  }
  arg1 = reinterpret_cast< sword::LocaleMgr * >(argp1);
  {
    try {
      sword::LocaleMgr::setSystemLocaleMgr(arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LocaleMgr_loadConfigDir(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::LocaleMgr *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "LocaleMgr_loadConfigDir", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__LocaleMgr, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LocaleMgr_loadConfigDir" "', argument " "1"" of type '" "sword::LocaleMgr *""'"); 
  }
  arg1 = reinterpret_cast< sword::LocaleMgr * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LocaleMgr_loadConfigDir" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    try {
      (arg1)->loadConfigDir((char const *)arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_LocaleMgr_getAvailableLocalesVector(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::LocaleMgr *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< sword::SWBuf,std::allocator< sword::SWBuf > > result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__LocaleMgr, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LocaleMgr_getAvailableLocalesVector" "', argument " "1"" of type '" "sword::LocaleMgr *""'"); 
  }
  arg1 = reinterpret_cast< sword::LocaleMgr * >(argp1);
  {
    try {
      result = sword_LocaleMgr_getAvailableLocalesVector(arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = swig::from(static_cast< std::vector< sword::SWBuf,std::allocator< sword::SWBuf > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *LocaleMgr_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_sword__LocaleMgr, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *LocaleMgr_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_URL(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  PyObject *swig_obj[1] ;
  sword::URL *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_URL" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  {
    try {
      result = (sword::URL *)new sword::URL((char const *)arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__URL, SWIG_POINTER_NEW |  0 );
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_URL_getProtocol(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::URL *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__URL, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "URL_getProtocol" "', argument " "1"" of type '" "sword::URL const *""'"); 
  }
  arg1 = reinterpret_cast< sword::URL * >(argp1);
  {
    try {
      result = (char *)((sword::URL const *)arg1)->getProtocol(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_URL_getHostName(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::URL *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__URL, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "URL_getHostName" "', argument " "1"" of type '" "sword::URL const *""'"); 
  }
  arg1 = reinterpret_cast< sword::URL * >(argp1);
  {
    try {
      result = (char *)((sword::URL const *)arg1)->getHostName(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_URL_getPath(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::URL *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__URL, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "URL_getPath" "', argument " "1"" of type '" "sword::URL const *""'"); 
  }
  arg1 = reinterpret_cast< sword::URL * >(argp1);
  {
    try {
      result = (char *)((sword::URL const *)arg1)->getPath(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_URL_getParameters(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::URL *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  sword::URL::ParameterMap *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__URL, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "URL_getParameters" "', argument " "1"" of type '" "sword::URL const *""'"); 
  }
  arg1 = reinterpret_cast< sword::URL * >(argp1);
  {
    try {
      result = (sword::URL::ParameterMap *) &((sword::URL const *)arg1)->getParameters(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = swig::from(static_cast< std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_URL_getParameterValue(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::URL *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  char *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "URL_getParameterValue", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__URL, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "URL_getParameterValue" "', argument " "1"" of type '" "sword::URL const *""'"); 
  }
  arg1 = reinterpret_cast< sword::URL * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "URL_getParameterValue" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    try {
      result = (char *)((sword::URL const *)arg1)->getParameterValue((char const *)arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_URL_encode(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  PyObject *swig_obj[1] ;
  sword::SWBuf result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "URL_encode" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  {
    try {
      result = sword::URL::encode((char const *)arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj((new sword::SWBuf(result)), SWIGTYPE_p_sword__SWBuf, SWIG_POINTER_OWN |  0 );
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_URL_decode(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  PyObject *swig_obj[1] ;
  sword::SWBuf result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "URL_decode" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  {
    try {
      result = sword::URL::decode((char const *)arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj((new sword::SWBuf(result)), SWIGTYPE_p_sword__SWBuf, SWIG_POINTER_OWN |  0 );
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_URL(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::URL *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__URL, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_URL" "', argument " "1"" of type '" "sword::URL *""'"); 
  }
  arg1 = reinterpret_cast< sword::URL * >(argp1);
  {
    try {
      delete arg1; 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *URL_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_sword__URL, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *URL_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_XMLTag__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  sword::XMLTag *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_XMLTag" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  {
    try {
      result = (sword::XMLTag *)new sword::XMLTag((char const *)arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__XMLTag, SWIG_POINTER_NEW |  0 );
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_XMLTag__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  sword::XMLTag *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (sword::XMLTag *)new sword::XMLTag(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__XMLTag, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_XMLTag__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::XMLTag *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  sword::XMLTag *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_sword__XMLTag,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_XMLTag" "', argument " "1"" of type '" "sword::XMLTag const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_XMLTag" "', argument " "1"" of type '" "sword::XMLTag const &""'"); 
  }
  arg1 = reinterpret_cast< sword::XMLTag * >(argp1);
  {
    try {
      result = (sword::XMLTag *)new sword::XMLTag((sword::XMLTag const &)*arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__XMLTag, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_XMLTag(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_XMLTag", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_XMLTag__SWIG_1(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_sword__XMLTag, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_XMLTag__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_XMLTag__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_XMLTag'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    sword::XMLTag::XMLTag(char const *)\n"
    "    sword::XMLTag::XMLTag()\n"
    "    sword::XMLTag::XMLTag(sword::XMLTag const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_XMLTag(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::XMLTag *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__XMLTag, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_XMLTag" "', argument " "1"" of type '" "sword::XMLTag *""'"); 
  }
  arg1 = reinterpret_cast< sword::XMLTag * >(argp1);
  {
    try {
      delete arg1; 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLTag_setText(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::XMLTag *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "XMLTag_setText", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__XMLTag, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLTag_setText" "', argument " "1"" of type '" "sword::XMLTag *""'"); 
  }
  arg1 = reinterpret_cast< sword::XMLTag * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XMLTag_setText" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    try {
      (arg1)->setText((char const *)arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLTag_getName(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::XMLTag *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__XMLTag, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLTag_getName" "', argument " "1"" of type '" "sword::XMLTag const *""'"); 
  }
  arg1 = reinterpret_cast< sword::XMLTag * >(argp1);
  {
    try {
      result = (char *)((sword::XMLTag const *)arg1)->getName(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLTag_isEmpty(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::XMLTag *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__XMLTag, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLTag_isEmpty" "', argument " "1"" of type '" "sword::XMLTag const *""'"); 
  }
  arg1 = reinterpret_cast< sword::XMLTag * >(argp1);
  {
    try {
      result = (bool)((sword::XMLTag const *)arg1)->isEmpty(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLTag_setEmpty(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::XMLTag *arg1 = 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "XMLTag_setEmpty", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__XMLTag, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLTag_setEmpty" "', argument " "1"" of type '" "sword::XMLTag *""'"); 
  }
  arg1 = reinterpret_cast< sword::XMLTag * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "XMLTag_setEmpty" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    try {
      (arg1)->setEmpty(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLTag_isEndTag__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::XMLTag *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  bool result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__XMLTag, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLTag_isEndTag" "', argument " "1"" of type '" "sword::XMLTag const *""'"); 
  }
  arg1 = reinterpret_cast< sword::XMLTag * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XMLTag_isEndTag" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    try {
      result = (bool)((sword::XMLTag const *)arg1)->isEndTag((char const *)arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLTag_isEndTag__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::XMLTag *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__XMLTag, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLTag_isEndTag" "', argument " "1"" of type '" "sword::XMLTag const *""'"); 
  }
  arg1 = reinterpret_cast< sword::XMLTag * >(argp1);
  {
    try {
      result = (bool)((sword::XMLTag const *)arg1)->isEndTag(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLTag_isEndTag(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "XMLTag_isEndTag", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__XMLTag, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_XMLTag_isEndTag__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__XMLTag, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_XMLTag_isEndTag__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'XMLTag_isEndTag'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    sword::XMLTag::isEndTag(char const *) const\n"
    "    sword::XMLTag::isEndTag() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_XMLTag_setEndTag(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::XMLTag *arg1 = 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "XMLTag_setEndTag", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__XMLTag, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLTag_setEndTag" "', argument " "1"" of type '" "sword::XMLTag *""'"); 
  }
  arg1 = reinterpret_cast< sword::XMLTag * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "XMLTag_setEndTag" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    try {
      (arg1)->setEndTag(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLTag_getAttributeNames(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::XMLTag *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  sword::StringList result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__XMLTag, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLTag_getAttributeNames" "', argument " "1"" of type '" "sword::XMLTag const *""'"); 
  }
  arg1 = reinterpret_cast< sword::XMLTag * >(argp1);
  {
    try {
      result = ((sword::XMLTag const *)arg1)->getAttributeNames(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = swig::from(static_cast< std::list< sword::SWBuf,std::allocator< sword::SWBuf > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLTag_getAttributePartCount__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::XMLTag *arg1 = 0 ;
  char *arg2 = 0 ;
  char arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  char val3 ;
  int ecode3 = 0 ;
  int result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__XMLTag, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLTag_getAttributePartCount" "', argument " "1"" of type '" "sword::XMLTag const *""'"); 
  }
  arg1 = reinterpret_cast< sword::XMLTag * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XMLTag_getAttributePartCount" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  ecode3 = SWIG_AsVal_char(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "XMLTag_getAttributePartCount" "', argument " "3"" of type '" "char""'");
  } 
  arg3 = static_cast< char >(val3);
  {
    try {
      result = (int)((sword::XMLTag const *)arg1)->getAttributePartCount((char const *)arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLTag_getAttributePartCount__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::XMLTag *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__XMLTag, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLTag_getAttributePartCount" "', argument " "1"" of type '" "sword::XMLTag const *""'"); 
  }
  arg1 = reinterpret_cast< sword::XMLTag * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XMLTag_getAttributePartCount" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    try {
      result = (int)((sword::XMLTag const *)arg1)->getAttributePartCount((char const *)arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLTag_getAttributePartCount(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "XMLTag_getAttributePartCount", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__XMLTag, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_XMLTag_getAttributePartCount__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__XMLTag, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_char(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_XMLTag_getAttributePartCount__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'XMLTag_getAttributePartCount'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    sword::XMLTag::getAttributePartCount(char const *,char) const\n"
    "    sword::XMLTag::getAttributePartCount(char const *) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_XMLTag_getAttribute__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::XMLTag *arg1 = 0 ;
  char *arg2 = 0 ;
  int arg3 ;
  char arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  char val4 ;
  int ecode4 = 0 ;
  char *result = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__XMLTag, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLTag_getAttribute" "', argument " "1"" of type '" "sword::XMLTag const *""'"); 
  }
  arg1 = reinterpret_cast< sword::XMLTag * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XMLTag_getAttribute" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "XMLTag_getAttribute" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_char(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "XMLTag_getAttribute" "', argument " "4"" of type '" "char""'");
  } 
  arg4 = static_cast< char >(val4);
  {
    try {
      result = (char *)((sword::XMLTag const *)arg1)->getAttribute((char const *)arg2,arg3,arg4); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLTag_getAttribute__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::XMLTag *arg1 = 0 ;
  char *arg2 = 0 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  char *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__XMLTag, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLTag_getAttribute" "', argument " "1"" of type '" "sword::XMLTag const *""'"); 
  }
  arg1 = reinterpret_cast< sword::XMLTag * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XMLTag_getAttribute" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "XMLTag_getAttribute" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  {
    try {
      result = (char *)((sword::XMLTag const *)arg1)->getAttribute((char const *)arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLTag_getAttribute__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::XMLTag *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  char *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__XMLTag, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLTag_getAttribute" "', argument " "1"" of type '" "sword::XMLTag const *""'"); 
  }
  arg1 = reinterpret_cast< sword::XMLTag * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XMLTag_getAttribute" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    try {
      result = (char *)((sword::XMLTag const *)arg1)->getAttribute((char const *)arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLTag_getAttribute(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "XMLTag_getAttribute", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__XMLTag, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_XMLTag_getAttribute__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__XMLTag, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_XMLTag_getAttribute__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__XMLTag, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_char(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_XMLTag_getAttribute__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'XMLTag_getAttribute'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    sword::XMLTag::getAttribute(char const *,int,char) const\n"
    "    sword::XMLTag::getAttribute(char const *,int) const\n"
    "    sword::XMLTag::getAttribute(char const *) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_XMLTag_setAttribute__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::XMLTag *arg1 = 0 ;
  char *arg2 = 0 ;
  char *arg3 = 0 ;
  int arg4 ;
  char arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  char val5 ;
  int ecode5 = 0 ;
  char *result = 0 ;
  
  (void)self;
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__XMLTag, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLTag_setAttribute" "', argument " "1"" of type '" "sword::XMLTag *""'"); 
  }
  arg1 = reinterpret_cast< sword::XMLTag * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XMLTag_setAttribute" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "XMLTag_setAttribute" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "XMLTag_setAttribute" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_char(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "XMLTag_setAttribute" "', argument " "5"" of type '" "char""'");
  } 
  arg5 = static_cast< char >(val5);
  {
    try {
      result = (char *)(arg1)->setAttribute((char const *)arg2,(char const *)arg3,arg4,arg5); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLTag_setAttribute__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::XMLTag *arg1 = 0 ;
  char *arg2 = 0 ;
  char *arg3 = 0 ;
  int arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  char *result = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__XMLTag, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLTag_setAttribute" "', argument " "1"" of type '" "sword::XMLTag *""'"); 
  }
  arg1 = reinterpret_cast< sword::XMLTag * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XMLTag_setAttribute" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "XMLTag_setAttribute" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "XMLTag_setAttribute" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  {
    try {
      result = (char *)(arg1)->setAttribute((char const *)arg2,(char const *)arg3,arg4); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLTag_setAttribute__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::XMLTag *arg1 = 0 ;
  char *arg2 = 0 ;
  char *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  char *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__XMLTag, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLTag_setAttribute" "', argument " "1"" of type '" "sword::XMLTag *""'"); 
  }
  arg1 = reinterpret_cast< sword::XMLTag * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XMLTag_setAttribute" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "XMLTag_setAttribute" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  {
    try {
      result = (char *)(arg1)->setAttribute((char const *)arg2,(char const *)arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLTag_setAttribute(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "XMLTag_setAttribute", 0, 5, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__XMLTag, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_XMLTag_setAttribute__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__XMLTag, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_XMLTag_setAttribute__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__XMLTag, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_char(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_XMLTag_setAttribute__SWIG_0(self, argc, argv);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'XMLTag_setAttribute'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    sword::XMLTag::setAttribute(char const *,char const *,int,char)\n"
    "    sword::XMLTag::setAttribute(char const *,char const *,int)\n"
    "    sword::XMLTag::setAttribute(char const *,char const *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_XMLTag_toString(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::XMLTag *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__XMLTag, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLTag_toString" "', argument " "1"" of type '" "sword::XMLTag const *""'"); 
  }
  arg1 = reinterpret_cast< sword::XMLTag * >(argp1);
  {
    try {
      result = (char *)((sword::XMLTag const *)arg1)->toString(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *XMLTag_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_sword__XMLTag, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *XMLTag_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_BasicFilterUserData(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWModule *arg1 = 0 ;
  sword::SWKey *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  sword::BasicFilterUserData *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_BasicFilterUserData", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BasicFilterUserData" "', argument " "1"" of type '" "sword::SWModule const *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWModule * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_sword__SWKey, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_BasicFilterUserData" "', argument " "2"" of type '" "sword::SWKey const *""'"); 
  }
  arg2 = reinterpret_cast< sword::SWKey * >(argp2);
  {
    try {
      result = (sword::BasicFilterUserData *)new sword::BasicFilterUserData((sword::SWModule const *)arg1,(sword::SWKey const *)arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__BasicFilterUserData, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_BasicFilterUserData(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::BasicFilterUserData *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__BasicFilterUserData, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BasicFilterUserData" "', argument " "1"" of type '" "sword::BasicFilterUserData *""'"); 
  }
  arg1 = reinterpret_cast< sword::BasicFilterUserData * >(argp1);
  {
    try {
      delete arg1; 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BasicFilterUserData_module_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::BasicFilterUserData *arg1 = 0 ;
  sword::SWModule *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "BasicFilterUserData_module_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__BasicFilterUserData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BasicFilterUserData_module_set" "', argument " "1"" of type '" "sword::BasicFilterUserData *""'"); 
  }
  arg1 = reinterpret_cast< sword::BasicFilterUserData * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_sword__SWModule, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BasicFilterUserData_module_set" "', argument " "2"" of type '" "sword::SWModule const *""'"); 
  }
  arg2 = reinterpret_cast< sword::SWModule * >(argp2);
  if (arg1) (arg1)->module = (sword::SWModule const *)arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BasicFilterUserData_module_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::BasicFilterUserData *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  sword::SWModule *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__BasicFilterUserData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BasicFilterUserData_module_get" "', argument " "1"" of type '" "sword::BasicFilterUserData *""'"); 
  }
  arg1 = reinterpret_cast< sword::BasicFilterUserData * >(argp1);
  result = (sword::SWModule *) ((arg1)->module);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__SWModule, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BasicFilterUserData_key_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::BasicFilterUserData *arg1 = 0 ;
  sword::SWKey *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "BasicFilterUserData_key_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__BasicFilterUserData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BasicFilterUserData_key_set" "', argument " "1"" of type '" "sword::BasicFilterUserData *""'"); 
  }
  arg1 = reinterpret_cast< sword::BasicFilterUserData * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_sword__SWKey, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BasicFilterUserData_key_set" "', argument " "2"" of type '" "sword::SWKey const *""'"); 
  }
  arg2 = reinterpret_cast< sword::SWKey * >(argp2);
  if (arg1) (arg1)->key = (sword::SWKey const *)arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BasicFilterUserData_key_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::BasicFilterUserData *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  sword::SWKey *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__BasicFilterUserData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BasicFilterUserData_key_get" "', argument " "1"" of type '" "sword::BasicFilterUserData *""'"); 
  }
  arg1 = reinterpret_cast< sword::BasicFilterUserData * >(argp1);
  result = (sword::SWKey *) ((arg1)->key);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__SWKey, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BasicFilterUserData_vkey_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::BasicFilterUserData *arg1 = 0 ;
  sword::VerseKey *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "BasicFilterUserData_vkey_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__BasicFilterUserData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BasicFilterUserData_vkey_set" "', argument " "1"" of type '" "sword::BasicFilterUserData *""'"); 
  }
  arg1 = reinterpret_cast< sword::BasicFilterUserData * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_sword__VerseKey, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BasicFilterUserData_vkey_set" "', argument " "2"" of type '" "sword::VerseKey const *""'"); 
  }
  arg2 = reinterpret_cast< sword::VerseKey * >(argp2);
  if (arg1) (arg1)->vkey = (sword::VerseKey const *)arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BasicFilterUserData_vkey_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::BasicFilterUserData *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  sword::VerseKey *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__BasicFilterUserData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BasicFilterUserData_vkey_get" "', argument " "1"" of type '" "sword::BasicFilterUserData *""'"); 
  }
  arg1 = reinterpret_cast< sword::BasicFilterUserData * >(argp1);
  result = (sword::VerseKey *) ((arg1)->vkey);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__VerseKey, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BasicFilterUserData_lastTextNode_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::BasicFilterUserData *arg1 = 0 ;
  sword::SWBuf *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "BasicFilterUserData_lastTextNode_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__BasicFilterUserData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BasicFilterUserData_lastTextNode_set" "', argument " "1"" of type '" "sword::BasicFilterUserData *""'"); 
  }
  arg1 = reinterpret_cast< sword::BasicFilterUserData * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_sword__SWBuf, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BasicFilterUserData_lastTextNode_set" "', argument " "2"" of type '" "sword::SWBuf *""'"); 
  }
  arg2 = reinterpret_cast< sword::SWBuf * >(argp2);
  if (arg1) (arg1)->lastTextNode = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BasicFilterUserData_lastTextNode_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::BasicFilterUserData *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  sword::SWBuf *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__BasicFilterUserData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BasicFilterUserData_lastTextNode_get" "', argument " "1"" of type '" "sword::BasicFilterUserData *""'"); 
  }
  arg1 = reinterpret_cast< sword::BasicFilterUserData * >(argp1);
  result = (sword::SWBuf *)& ((arg1)->lastTextNode);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__SWBuf, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BasicFilterUserData_lastSuspendSegment_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::BasicFilterUserData *arg1 = 0 ;
  sword::SWBuf *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "BasicFilterUserData_lastSuspendSegment_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__BasicFilterUserData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BasicFilterUserData_lastSuspendSegment_set" "', argument " "1"" of type '" "sword::BasicFilterUserData *""'"); 
  }
  arg1 = reinterpret_cast< sword::BasicFilterUserData * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_sword__SWBuf, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BasicFilterUserData_lastSuspendSegment_set" "', argument " "2"" of type '" "sword::SWBuf *""'"); 
  }
  arg2 = reinterpret_cast< sword::SWBuf * >(argp2);
  if (arg1) (arg1)->lastSuspendSegment = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BasicFilterUserData_lastSuspendSegment_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::BasicFilterUserData *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  sword::SWBuf *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__BasicFilterUserData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BasicFilterUserData_lastSuspendSegment_get" "', argument " "1"" of type '" "sword::BasicFilterUserData *""'"); 
  }
  arg1 = reinterpret_cast< sword::BasicFilterUserData * >(argp1);
  result = (sword::SWBuf *)& ((arg1)->lastSuspendSegment);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__SWBuf, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BasicFilterUserData_suspendTextPassThru_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::BasicFilterUserData *arg1 = 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "BasicFilterUserData_suspendTextPassThru_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__BasicFilterUserData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BasicFilterUserData_suspendTextPassThru_set" "', argument " "1"" of type '" "sword::BasicFilterUserData *""'"); 
  }
  arg1 = reinterpret_cast< sword::BasicFilterUserData * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BasicFilterUserData_suspendTextPassThru_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->suspendTextPassThru = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BasicFilterUserData_suspendTextPassThru_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::BasicFilterUserData *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__BasicFilterUserData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BasicFilterUserData_suspendTextPassThru_get" "', argument " "1"" of type '" "sword::BasicFilterUserData *""'"); 
  }
  arg1 = reinterpret_cast< sword::BasicFilterUserData * >(argp1);
  result = (bool) ((arg1)->suspendTextPassThru);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BasicFilterUserData_supressAdjacentWhitespace_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::BasicFilterUserData *arg1 = 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "BasicFilterUserData_supressAdjacentWhitespace_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__BasicFilterUserData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BasicFilterUserData_supressAdjacentWhitespace_set" "', argument " "1"" of type '" "sword::BasicFilterUserData *""'"); 
  }
  arg1 = reinterpret_cast< sword::BasicFilterUserData * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BasicFilterUserData_supressAdjacentWhitespace_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->supressAdjacentWhitespace = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BasicFilterUserData_supressAdjacentWhitespace_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::BasicFilterUserData *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__BasicFilterUserData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BasicFilterUserData_supressAdjacentWhitespace_get" "', argument " "1"" of type '" "sword::BasicFilterUserData *""'"); 
  }
  arg1 = reinterpret_cast< sword::BasicFilterUserData * >(argp1);
  result = (bool) ((arg1)->supressAdjacentWhitespace);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *BasicFilterUserData_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_sword__BasicFilterUserData, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *BasicFilterUserData_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SWBasicFilter(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWBasicFilter *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SWBasicFilter", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (sword::SWBasicFilter *)new sword::SWBasicFilter(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__SWBasicFilter, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWBasicFilter_processText__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::SWBasicFilter *arg1 = 0 ;
  sword::SWBuf *arg2 = 0 ;
  sword::SWKey *arg3 = 0 ;
  sword::SWModule *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  char result;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWBasicFilter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWBasicFilter_processText" "', argument " "1"" of type '" "sword::SWBasicFilter *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWBasicFilter * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_sword__SWBuf,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SWBasicFilter_processText" "', argument " "2"" of type '" "sword::SWBuf &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SWBasicFilter_processText" "', argument " "2"" of type '" "sword::SWBuf &""'"); 
  }
  arg2 = reinterpret_cast< sword::SWBuf * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_sword__SWKey, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SWBasicFilter_processText" "', argument " "3"" of type '" "sword::SWKey const *""'"); 
  }
  arg3 = reinterpret_cast< sword::SWKey * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_sword__SWModule, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SWBasicFilter_processText" "', argument " "4"" of type '" "sword::SWModule const *""'"); 
  }
  arg4 = reinterpret_cast< sword::SWModule * >(argp4);
  {
    try {
      result = (char)(arg1)->processText(*arg2,(sword::SWKey const *)arg3,(sword::SWModule const *)arg4); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_char(static_cast< char >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWBasicFilter_processText__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::SWBasicFilter *arg1 = 0 ;
  sword::SWBuf *arg2 = 0 ;
  sword::SWKey *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  char result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWBasicFilter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWBasicFilter_processText" "', argument " "1"" of type '" "sword::SWBasicFilter *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWBasicFilter * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_sword__SWBuf,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SWBasicFilter_processText" "', argument " "2"" of type '" "sword::SWBuf &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SWBasicFilter_processText" "', argument " "2"" of type '" "sword::SWBuf &""'"); 
  }
  arg2 = reinterpret_cast< sword::SWBuf * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_sword__SWKey, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SWBasicFilter_processText" "', argument " "3"" of type '" "sword::SWKey const *""'"); 
  }
  arg3 = reinterpret_cast< sword::SWKey * >(argp3);
  {
    try {
      result = (char)(arg1)->processText(*arg2,(sword::SWKey const *)arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_char(static_cast< char >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWBasicFilter_processText__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::SWBasicFilter *arg1 = 0 ;
  sword::SWBuf *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  char result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWBasicFilter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWBasicFilter_processText" "', argument " "1"" of type '" "sword::SWBasicFilter *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWBasicFilter * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_sword__SWBuf,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SWBasicFilter_processText" "', argument " "2"" of type '" "sword::SWBuf &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SWBasicFilter_processText" "', argument " "2"" of type '" "sword::SWBuf &""'"); 
  }
  arg2 = reinterpret_cast< sword::SWBuf * >(argp2);
  {
    try {
      result = (char)(arg1)->processText(*arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_char(static_cast< char >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWBasicFilter_processText(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SWBasicFilter_processText", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__SWBasicFilter, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_sword__SWBuf, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SWBasicFilter_processText__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__SWBasicFilter, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_sword__SWBuf, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_sword__SWKey, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SWBasicFilter_processText__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__SWBasicFilter, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_sword__SWBuf, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_sword__SWKey, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_sword__SWModule, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_SWBasicFilter_processText__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SWBasicFilter_processText'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    sword::SWBasicFilter::processText(sword::SWBuf &,sword::SWKey const *,sword::SWModule const *)\n"
    "    sword::SWBasicFilter::processText(sword::SWBuf &,sword::SWKey const *)\n"
    "    sword::SWBasicFilter::processText(sword::SWBuf &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SWBasicFilter(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWBasicFilter *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWBasicFilter, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SWBasicFilter" "', argument " "1"" of type '" "sword::SWBasicFilter *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWBasicFilter * >(argp1);
  {
    try {
      delete arg1; 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SWBasicFilter_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_sword__SWBasicFilter, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SWBasicFilter_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_OSISHTMLHREF(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::OSISHTMLHREF *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_OSISHTMLHREF", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (sword::OSISHTMLHREF *)new sword::OSISHTMLHREF(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__OSISHTMLHREF, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_OSISHTMLHREF_setMorphFirst__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::OSISHTMLHREF *arg1 = 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__OSISHTMLHREF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OSISHTMLHREF_setMorphFirst" "', argument " "1"" of type '" "sword::OSISHTMLHREF *""'"); 
  }
  arg1 = reinterpret_cast< sword::OSISHTMLHREF * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "OSISHTMLHREF_setMorphFirst" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    try {
      (arg1)->setMorphFirst(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_OSISHTMLHREF_setMorphFirst__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::OSISHTMLHREF *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__OSISHTMLHREF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OSISHTMLHREF_setMorphFirst" "', argument " "1"" of type '" "sword::OSISHTMLHREF *""'"); 
  }
  arg1 = reinterpret_cast< sword::OSISHTMLHREF * >(argp1);
  {
    try {
      (arg1)->setMorphFirst(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_OSISHTMLHREF_setMorphFirst(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "OSISHTMLHREF_setMorphFirst", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__OSISHTMLHREF, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_OSISHTMLHREF_setMorphFirst__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__OSISHTMLHREF, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_OSISHTMLHREF_setMorphFirst__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'OSISHTMLHREF_setMorphFirst'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    sword::OSISHTMLHREF::setMorphFirst(bool)\n"
    "    sword::OSISHTMLHREF::setMorphFirst()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_OSISHTMLHREF_setRenderNoteNumbers__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::OSISHTMLHREF *arg1 = 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__OSISHTMLHREF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OSISHTMLHREF_setRenderNoteNumbers" "', argument " "1"" of type '" "sword::OSISHTMLHREF *""'"); 
  }
  arg1 = reinterpret_cast< sword::OSISHTMLHREF * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "OSISHTMLHREF_setRenderNoteNumbers" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    try {
      (arg1)->setRenderNoteNumbers(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_OSISHTMLHREF_setRenderNoteNumbers__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::OSISHTMLHREF *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__OSISHTMLHREF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OSISHTMLHREF_setRenderNoteNumbers" "', argument " "1"" of type '" "sword::OSISHTMLHREF *""'"); 
  }
  arg1 = reinterpret_cast< sword::OSISHTMLHREF * >(argp1);
  {
    try {
      (arg1)->setRenderNoteNumbers(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_OSISHTMLHREF_setRenderNoteNumbers(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "OSISHTMLHREF_setRenderNoteNumbers", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__OSISHTMLHREF, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_OSISHTMLHREF_setRenderNoteNumbers__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__OSISHTMLHREF, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_OSISHTMLHREF_setRenderNoteNumbers__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'OSISHTMLHREF_setRenderNoteNumbers'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    sword::OSISHTMLHREF::setRenderNoteNumbers(bool)\n"
    "    sword::OSISHTMLHREF::setRenderNoteNumbers()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_OSISHTMLHREF(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::OSISHTMLHREF *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__OSISHTMLHREF, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_OSISHTMLHREF" "', argument " "1"" of type '" "sword::OSISHTMLHREF *""'"); 
  }
  arg1 = reinterpret_cast< sword::OSISHTMLHREF * >(argp1);
  {
    try {
      delete arg1; 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *OSISHTMLHREF_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_sword__OSISHTMLHREF, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *OSISHTMLHREF_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_ThMLHTMLHREF(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::ThMLHTMLHREF *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_ThMLHTMLHREF", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (sword::ThMLHTMLHREF *)new sword::ThMLHTMLHREF(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__ThMLHTMLHREF, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ThMLHTMLHREF_getImagePrefix(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::ThMLHTMLHREF *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__ThMLHTMLHREF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ThMLHTMLHREF_getImagePrefix" "', argument " "1"" of type '" "sword::ThMLHTMLHREF *""'"); 
  }
  arg1 = reinterpret_cast< sword::ThMLHTMLHREF * >(argp1);
  {
    try {
      result = (char *)(arg1)->getImagePrefix(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ThMLHTMLHREF_setImagePrefix(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::ThMLHTMLHREF *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ThMLHTMLHREF_setImagePrefix", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__ThMLHTMLHREF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ThMLHTMLHREF_setImagePrefix" "', argument " "1"" of type '" "sword::ThMLHTMLHREF *""'"); 
  }
  arg1 = reinterpret_cast< sword::ThMLHTMLHREF * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ThMLHTMLHREF_setImagePrefix" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    try {
      (arg1)->setImagePrefix((char const *)arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ThMLHTMLHREF_setRenderNoteNumbers__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::ThMLHTMLHREF *arg1 = 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__ThMLHTMLHREF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ThMLHTMLHREF_setRenderNoteNumbers" "', argument " "1"" of type '" "sword::ThMLHTMLHREF *""'"); 
  }
  arg1 = reinterpret_cast< sword::ThMLHTMLHREF * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ThMLHTMLHREF_setRenderNoteNumbers" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    try {
      (arg1)->setRenderNoteNumbers(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ThMLHTMLHREF_setRenderNoteNumbers__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::ThMLHTMLHREF *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__ThMLHTMLHREF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ThMLHTMLHREF_setRenderNoteNumbers" "', argument " "1"" of type '" "sword::ThMLHTMLHREF *""'"); 
  }
  arg1 = reinterpret_cast< sword::ThMLHTMLHREF * >(argp1);
  {
    try {
      (arg1)->setRenderNoteNumbers(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ThMLHTMLHREF_setRenderNoteNumbers(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "ThMLHTMLHREF_setRenderNoteNumbers", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__ThMLHTMLHREF, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_ThMLHTMLHREF_setRenderNoteNumbers__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__ThMLHTMLHREF, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_ThMLHTMLHREF_setRenderNoteNumbers__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ThMLHTMLHREF_setRenderNoteNumbers'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    sword::ThMLHTMLHREF::setRenderNoteNumbers(bool)\n"
    "    sword::ThMLHTMLHREF::setRenderNoteNumbers()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_ThMLHTMLHREF(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::ThMLHTMLHREF *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__ThMLHTMLHREF, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ThMLHTMLHREF" "', argument " "1"" of type '" "sword::ThMLHTMLHREF *""'"); 
  }
  arg1 = reinterpret_cast< sword::ThMLHTMLHREF * >(argp1);
  {
    try {
      delete arg1; 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ThMLHTMLHREF_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_sword__ThMLHTMLHREF, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *ThMLHTMLHREF_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_GBFHTMLHREF(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::GBFHTMLHREF *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_GBFHTMLHREF", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (sword::GBFHTMLHREF *)new sword::GBFHTMLHREF(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__GBFHTMLHREF, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GBFHTMLHREF_setRenderNoteNumbers__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::GBFHTMLHREF *arg1 = 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__GBFHTMLHREF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBFHTMLHREF_setRenderNoteNumbers" "', argument " "1"" of type '" "sword::GBFHTMLHREF *""'"); 
  }
  arg1 = reinterpret_cast< sword::GBFHTMLHREF * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBFHTMLHREF_setRenderNoteNumbers" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    try {
      (arg1)->setRenderNoteNumbers(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GBFHTMLHREF_setRenderNoteNumbers__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::GBFHTMLHREF *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__GBFHTMLHREF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBFHTMLHREF_setRenderNoteNumbers" "', argument " "1"" of type '" "sword::GBFHTMLHREF *""'"); 
  }
  arg1 = reinterpret_cast< sword::GBFHTMLHREF * >(argp1);
  {
    try {
      (arg1)->setRenderNoteNumbers(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GBFHTMLHREF_setRenderNoteNumbers(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "GBFHTMLHREF_setRenderNoteNumbers", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__GBFHTMLHREF, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_GBFHTMLHREF_setRenderNoteNumbers__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__GBFHTMLHREF, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_GBFHTMLHREF_setRenderNoteNumbers__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'GBFHTMLHREF_setRenderNoteNumbers'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    sword::GBFHTMLHREF::setRenderNoteNumbers(bool)\n"
    "    sword::GBFHTMLHREF::setRenderNoteNumbers()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_GBFHTMLHREF(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::GBFHTMLHREF *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__GBFHTMLHREF, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBFHTMLHREF" "', argument " "1"" of type '" "sword::GBFHTMLHREF *""'"); 
  }
  arg1 = reinterpret_cast< sword::GBFHTMLHREF * >(argp1);
  {
    try {
      delete arg1; 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *GBFHTMLHREF_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_sword__GBFHTMLHREF, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *GBFHTMLHREF_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_UTF8HTML(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::UTF8HTML *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_UTF8HTML", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (sword::UTF8HTML *)new sword::UTF8HTML(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__UTF8HTML, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UTF8HTML_processText__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::UTF8HTML *arg1 = 0 ;
  sword::SWBuf *arg2 = 0 ;
  sword::SWKey *arg3 = 0 ;
  sword::SWModule *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  char result;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__UTF8HTML, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UTF8HTML_processText" "', argument " "1"" of type '" "sword::UTF8HTML *""'"); 
  }
  arg1 = reinterpret_cast< sword::UTF8HTML * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_sword__SWBuf,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "UTF8HTML_processText" "', argument " "2"" of type '" "sword::SWBuf &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "UTF8HTML_processText" "', argument " "2"" of type '" "sword::SWBuf &""'"); 
  }
  arg2 = reinterpret_cast< sword::SWBuf * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_sword__SWKey, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "UTF8HTML_processText" "', argument " "3"" of type '" "sword::SWKey const *""'"); 
  }
  arg3 = reinterpret_cast< sword::SWKey * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_sword__SWModule, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "UTF8HTML_processText" "', argument " "4"" of type '" "sword::SWModule const *""'"); 
  }
  arg4 = reinterpret_cast< sword::SWModule * >(argp4);
  {
    try {
      result = (char)(arg1)->processText(*arg2,(sword::SWKey const *)arg3,(sword::SWModule const *)arg4); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_char(static_cast< char >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UTF8HTML_processText__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::UTF8HTML *arg1 = 0 ;
  sword::SWBuf *arg2 = 0 ;
  sword::SWKey *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  char result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__UTF8HTML, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UTF8HTML_processText" "', argument " "1"" of type '" "sword::UTF8HTML *""'"); 
  }
  arg1 = reinterpret_cast< sword::UTF8HTML * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_sword__SWBuf,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "UTF8HTML_processText" "', argument " "2"" of type '" "sword::SWBuf &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "UTF8HTML_processText" "', argument " "2"" of type '" "sword::SWBuf &""'"); 
  }
  arg2 = reinterpret_cast< sword::SWBuf * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_sword__SWKey, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "UTF8HTML_processText" "', argument " "3"" of type '" "sword::SWKey const *""'"); 
  }
  arg3 = reinterpret_cast< sword::SWKey * >(argp3);
  {
    try {
      result = (char)(arg1)->processText(*arg2,(sword::SWKey const *)arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_char(static_cast< char >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UTF8HTML_processText__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::UTF8HTML *arg1 = 0 ;
  sword::SWBuf *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  char result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__UTF8HTML, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UTF8HTML_processText" "', argument " "1"" of type '" "sword::UTF8HTML *""'"); 
  }
  arg1 = reinterpret_cast< sword::UTF8HTML * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_sword__SWBuf,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "UTF8HTML_processText" "', argument " "2"" of type '" "sword::SWBuf &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "UTF8HTML_processText" "', argument " "2"" of type '" "sword::SWBuf &""'"); 
  }
  arg2 = reinterpret_cast< sword::SWBuf * >(argp2);
  {
    try {
      result = (char)(arg1)->processText(*arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_char(static_cast< char >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UTF8HTML_processText(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "UTF8HTML_processText", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__UTF8HTML, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_sword__SWBuf, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_UTF8HTML_processText__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__UTF8HTML, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_sword__SWBuf, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_sword__SWKey, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_UTF8HTML_processText__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__UTF8HTML, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_sword__SWBuf, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_sword__SWKey, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_sword__SWModule, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_UTF8HTML_processText__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'UTF8HTML_processText'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    sword::UTF8HTML::processText(sword::SWBuf &,sword::SWKey const *,sword::SWModule const *)\n"
    "    sword::UTF8HTML::processText(sword::SWBuf &,sword::SWKey const *)\n"
    "    sword::UTF8HTML::processText(sword::SWBuf &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_UTF8HTML(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::UTF8HTML *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__UTF8HTML, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_UTF8HTML" "', argument " "1"" of type '" "sword::UTF8HTML *""'"); 
  }
  arg1 = reinterpret_cast< sword::UTF8HTML * >(argp1);
  {
    try {
      delete arg1; 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *UTF8HTML_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_sword__UTF8HTML, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *UTF8HTML_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_delete_MarkupCallback(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MarkupCallback *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_MarkupCallback, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MarkupCallback" "', argument " "1"" of type '" "MarkupCallback *""'"); 
  }
  arg1 = reinterpret_cast< MarkupCallback * >(argp1);
  {
    try {
      delete arg1; 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MarkupCallback_run(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MarkupCallback *arg1 = 0 ;
  sword::SWModule *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  Swig::Director *director = 0;
  bool upcall = false;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "MarkupCallback_run", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_MarkupCallback, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkupCallback_run" "', argument " "1"" of type '" "MarkupCallback *""'"); 
  }
  arg1 = reinterpret_cast< MarkupCallback * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_sword__SWModule, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MarkupCallback_run" "', argument " "2"" of type '" "sword::SWModule *""'"); 
  }
  arg2 = reinterpret_cast< sword::SWModule * >(argp2);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          result = (bool)(arg1)->MarkupCallback::run(arg2);
        } else {
          result = (bool)(arg1)->run(arg2);
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MarkupCallback(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PyObject *arg1 = 0 ;
  PyObject *swig_obj[1] ;
  MarkupCallback *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  arg1 = swig_obj[0];
  {
    try {
      if ( arg1 != Py_None ) {
        /* subclassed */
        result = (MarkupCallback *)new SwigDirector_MarkupCallback(arg1); 
      } else {
        result = (MarkupCallback *)new MarkupCallback(); 
      }
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_MarkupCallback, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_disown_MarkupCallback(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MarkupCallback *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_MarkupCallback, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "disown_MarkupCallback" "', argument " "1"" of type '" "MarkupCallback *""'"); 
  }
  arg1 = reinterpret_cast< MarkupCallback * >(argp1);
  {
    Swig::Director *director = SWIG_DIRECTOR_CAST(arg1);
    if (director) director->swig_disown();
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *MarkupCallback_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_MarkupCallback, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *MarkupCallback_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_MyMarkup__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  MarkupCallback *arg1 = 0 ;
  char arg2 ;
  char arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char val2 ;
  int ecode2 = 0 ;
  char val3 ;
  int ecode3 = 0 ;
  MyMarkup *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_MarkupCallback, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MyMarkup" "', argument " "1"" of type '" "MarkupCallback *""'"); 
  }
  arg1 = reinterpret_cast< MarkupCallback * >(argp1);
  ecode2 = SWIG_AsVal_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MyMarkup" "', argument " "2"" of type '" "char""'");
  } 
  arg2 = static_cast< char >(val2);
  ecode3 = SWIG_AsVal_char(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_MyMarkup" "', argument " "3"" of type '" "char""'");
  } 
  arg3 = static_cast< char >(val3);
  {
    try {
      result = (MyMarkup *)new MyMarkup(arg1,arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_MyMarkup, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MyMarkup__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  MarkupCallback *arg1 = 0 ;
  char arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char val2 ;
  int ecode2 = 0 ;
  MyMarkup *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_MarkupCallback, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MyMarkup" "', argument " "1"" of type '" "MarkupCallback *""'"); 
  }
  arg1 = reinterpret_cast< MarkupCallback * >(argp1);
  ecode2 = SWIG_AsVal_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MyMarkup" "', argument " "2"" of type '" "char""'");
  } 
  arg2 = static_cast< char >(val2);
  {
    try {
      result = (MyMarkup *)new MyMarkup(arg1,arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_MyMarkup, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MyMarkup__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  MarkupCallback *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  MyMarkup *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_MarkupCallback, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MyMarkup" "', argument " "1"" of type '" "MarkupCallback *""'"); 
  }
  arg1 = reinterpret_cast< MarkupCallback * >(argp1);
  {
    try {
      result = (MyMarkup *)new MyMarkup(arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_MyMarkup, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MyMarkup(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_MyMarkup", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_MarkupCallback, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_MyMarkup__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_MarkupCallback, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_char(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_MyMarkup__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_MarkupCallback, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_char(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_char(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_MyMarkup__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_MyMarkup'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    MyMarkup::MyMarkup(MarkupCallback *,char,char)\n"
    "    MyMarkup::MyMarkup(MarkupCallback *,char)\n"
    "    MyMarkup::MyMarkup(MarkupCallback *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_MyMarkup(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MyMarkup *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_MyMarkup, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MyMarkup" "', argument " "1"" of type '" "MyMarkup *""'"); 
  }
  arg1 = reinterpret_cast< MyMarkup * >(argp1);
  {
    try {
      delete arg1; 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MyMarkup_delCallback(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MyMarkup *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_MyMarkup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MyMarkup_delCallback" "', argument " "1"" of type '" "MyMarkup *""'"); 
  }
  arg1 = reinterpret_cast< MyMarkup * >(argp1);
  {
    try {
      (arg1)->delCallback(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MyMarkup_setCallback(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MyMarkup *arg1 = 0 ;
  MarkupCallback *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "MyMarkup_setCallback", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_MyMarkup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MyMarkup_setCallback" "', argument " "1"" of type '" "MyMarkup *""'"); 
  }
  arg1 = reinterpret_cast< MyMarkup * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_MarkupCallback, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MyMarkup_setCallback" "', argument " "2"" of type '" "MarkupCallback *""'"); 
  }
  arg2 = reinterpret_cast< MarkupCallback * >(argp2);
  {
    try {
      (arg1)->setCallback(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MyMarkup_call(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MyMarkup *arg1 = 0 ;
  sword::SWModule *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "MyMarkup_call", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_MyMarkup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MyMarkup_call" "', argument " "1"" of type '" "MyMarkup *""'"); 
  }
  arg1 = reinterpret_cast< MyMarkup * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_sword__SWModule, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MyMarkup_call" "', argument " "2"" of type '" "sword::SWModule *""'"); 
  }
  arg2 = reinterpret_cast< sword::SWModule * >(argp2);
  {
    try {
      result = (bool)(arg1)->call(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *MyMarkup_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_MyMarkup, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *MyMarkup_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_ReturnSuccess__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  ReturnSuccess *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (ReturnSuccess *)new ReturnSuccess(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ReturnSuccess, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ReturnSuccess__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  int arg2 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  ReturnSuccess *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ReturnSuccess" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ReturnSuccess" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    try {
      result = (ReturnSuccess *)new ReturnSuccess((char const *)arg1,arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ReturnSuccess, SWIG_POINTER_NEW |  0 );
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ReturnSuccess(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_ReturnSuccess", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_ReturnSuccess__SWIG_0(self, argc, argv);
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_ReturnSuccess__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_ReturnSuccess'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    ReturnSuccess::ReturnSuccess()\n"
    "    ReturnSuccess::ReturnSuccess(char const *,int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_ReturnSuccess(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ReturnSuccess *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ReturnSuccess, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ReturnSuccess" "', argument " "1"" of type '" "ReturnSuccess *""'"); 
  }
  arg1 = reinterpret_cast< ReturnSuccess * >(argp1);
  {
    try {
      delete arg1; 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ReturnSuccess_data_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ReturnSuccess *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ReturnSuccess_data_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ReturnSuccess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ReturnSuccess_data_set" "', argument " "1"" of type '" "ReturnSuccess *""'"); 
  }
  arg1 = reinterpret_cast< ReturnSuccess * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ReturnSuccess_data_set" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  if (arg2) {
    size_t size = strlen(reinterpret_cast< const char * >(reinterpret_cast< const char * >(arg2))) + 1;
    arg1->data = (char const *)reinterpret_cast< char* >(memcpy(new char[size], arg2, sizeof(char)*(size)));
  } else {
    arg1->data = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ReturnSuccess_data_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ReturnSuccess *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ReturnSuccess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ReturnSuccess_data_get" "', argument " "1"" of type '" "ReturnSuccess *""'"); 
  }
  arg1 = reinterpret_cast< ReturnSuccess * >(argp1);
  result = (char *) ((arg1)->data);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ReturnSuccess_success_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ReturnSuccess *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ReturnSuccess_success_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ReturnSuccess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ReturnSuccess_success_set" "', argument " "1"" of type '" "ReturnSuccess *""'"); 
  }
  arg1 = reinterpret_cast< ReturnSuccess * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ReturnSuccess_success_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  if (arg1) (arg1)->success = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ReturnSuccess_success_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ReturnSuccess *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ReturnSuccess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ReturnSuccess_success_get" "', argument " "1"" of type '" "ReturnSuccess *""'"); 
  }
  arg1 = reinterpret_cast< ReturnSuccess * >(argp1);
  result = (int) ((arg1)->success);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ReturnSuccess_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ReturnSuccess, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *ReturnSuccess_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_delete_RenderCallback(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  RenderCallback *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_RenderCallback, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RenderCallback" "', argument " "1"" of type '" "RenderCallback *""'"); 
  }
  arg1 = reinterpret_cast< RenderCallback * >(argp1);
  {
    try {
      delete arg1; 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RenderCallback_run(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  RenderCallback *arg1 = 0 ;
  sword::SWBuf *arg2 = 0 ;
  char *arg3 = 0 ;
  sword::BasicFilterUserData *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PyObject *swig_obj[4] ;
  Swig::Director *director = 0;
  bool upcall = false;
  ReturnSuccess result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "RenderCallback_run", 4, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_RenderCallback, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RenderCallback_run" "', argument " "1"" of type '" "RenderCallback *""'"); 
  }
  arg1 = reinterpret_cast< RenderCallback * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_sword__SWBuf,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RenderCallback_run" "', argument " "2"" of type '" "sword::SWBuf &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "RenderCallback_run" "', argument " "2"" of type '" "sword::SWBuf &""'"); 
  }
  arg2 = reinterpret_cast< sword::SWBuf * >(argp2);
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RenderCallback_run" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_sword__BasicFilterUserData, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "RenderCallback_run" "', argument " "4"" of type '" "sword::BasicFilterUserData *""'"); 
  }
  arg4 = reinterpret_cast< sword::BasicFilterUserData * >(argp4);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          result = (arg1)->RenderCallback::run(*arg2,(char const *)arg3,arg4);
        } else {
          result = (arg1)->run(*arg2,(char const *)arg3,arg4);
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_NewPointerObj((new ReturnSuccess(result)), SWIGTYPE_p_ReturnSuccess, SWIG_POINTER_OWN |  0 );
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return resultobj;
fail:
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RenderCallback(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PyObject *arg1 = 0 ;
  PyObject *swig_obj[1] ;
  RenderCallback *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  arg1 = swig_obj[0];
  {
    try {
      if ( arg1 != Py_None ) {
        /* subclassed */
        result = (RenderCallback *)new SwigDirector_RenderCallback(arg1); 
      } else {
        result = (RenderCallback *)new RenderCallback(); 
      }
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_RenderCallback, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_disown_RenderCallback(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  RenderCallback *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_RenderCallback, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "disown_RenderCallback" "', argument " "1"" of type '" "RenderCallback *""'"); 
  }
  arg1 = reinterpret_cast< RenderCallback * >(argp1);
  {
    Swig::Director *director = SWIG_DIRECTOR_CAST(arg1);
    if (director) director->swig_disown();
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *RenderCallback_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_RenderCallback, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *RenderCallback_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_PyOSISHTMLHREF_removeTokenSubstitute(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PyOSISHTMLHREF *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "PyOSISHTMLHREF_removeTokenSubstitute", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PyOSISHTMLHREF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyOSISHTMLHREF_removeTokenSubstitute" "', argument " "1"" of type '" "PyOSISHTMLHREF *""'"); 
  }
  arg1 = reinterpret_cast< PyOSISHTMLHREF * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyOSISHTMLHREF_removeTokenSubstitute" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    try {
      (arg1)->removeTokenSubstitute((char const *)arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_PyOSISHTMLHREF_addTokenSubstitute(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PyOSISHTMLHREF *arg1 = 0 ;
  char *arg2 = 0 ;
  char *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "PyOSISHTMLHREF_addTokenSubstitute", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PyOSISHTMLHREF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyOSISHTMLHREF_addTokenSubstitute" "', argument " "1"" of type '" "PyOSISHTMLHREF *""'"); 
  }
  arg1 = reinterpret_cast< PyOSISHTMLHREF * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyOSISHTMLHREF_addTokenSubstitute" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PyOSISHTMLHREF_addTokenSubstitute" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  {
    try {
      (arg1)->addTokenSubstitute((char const *)arg2,(char const *)arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_PyOSISHTMLHREF_addAllowedEscapeString(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PyOSISHTMLHREF *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "PyOSISHTMLHREF_addAllowedEscapeString", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PyOSISHTMLHREF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyOSISHTMLHREF_addAllowedEscapeString" "', argument " "1"" of type '" "PyOSISHTMLHREF *""'"); 
  }
  arg1 = reinterpret_cast< PyOSISHTMLHREF * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyOSISHTMLHREF_addAllowedEscapeString" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    try {
      (arg1)->addAllowedEscapeString((char const *)arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_PyOSISHTMLHREF_removeAllowedEscapeString(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PyOSISHTMLHREF *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "PyOSISHTMLHREF_removeAllowedEscapeString", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PyOSISHTMLHREF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyOSISHTMLHREF_removeAllowedEscapeString" "', argument " "1"" of type '" "PyOSISHTMLHREF *""'"); 
  }
  arg1 = reinterpret_cast< PyOSISHTMLHREF * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyOSISHTMLHREF_removeAllowedEscapeString" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    try {
      (arg1)->removeAllowedEscapeString((char const *)arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PyOSISHTMLHREF(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  RenderCallback *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  PyOSISHTMLHREF *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_RenderCallback, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PyOSISHTMLHREF" "', argument " "1"" of type '" "RenderCallback *""'"); 
  }
  arg1 = reinterpret_cast< RenderCallback * >(argp1);
  {
    try {
      result = (PyOSISHTMLHREF *)new PyOSISHTMLHREF(arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_PyOSISHTMLHREF, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PyOSISHTMLHREF_getData(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::BasicFilterUserData *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  OSISData *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__BasicFilterUserData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyOSISHTMLHREF_getData" "', argument " "1"" of type '" "sword::BasicFilterUserData *""'"); 
  }
  arg1 = reinterpret_cast< sword::BasicFilterUserData * >(argp1);
  {
    try {
      result = (OSISData *)PyOSISHTMLHREF::getData(arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OSISData, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_PyOSISHTMLHREF(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PyOSISHTMLHREF *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PyOSISHTMLHREF, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyOSISHTMLHREF" "', argument " "1"" of type '" "PyOSISHTMLHREF *""'"); 
  }
  arg1 = reinterpret_cast< PyOSISHTMLHREF * >(argp1);
  {
    try {
      delete arg1; 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PyOSISHTMLHREF_delCallback(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PyOSISHTMLHREF *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PyOSISHTMLHREF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyOSISHTMLHREF_delCallback" "', argument " "1"" of type '" "PyOSISHTMLHREF *""'"); 
  }
  arg1 = reinterpret_cast< PyOSISHTMLHREF * >(argp1);
  {
    try {
      (arg1)->delCallback(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PyOSISHTMLHREF_setCallback(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PyOSISHTMLHREF *arg1 = 0 ;
  RenderCallback *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "PyOSISHTMLHREF_setCallback", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PyOSISHTMLHREF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyOSISHTMLHREF_setCallback" "', argument " "1"" of type '" "PyOSISHTMLHREF *""'"); 
  }
  arg1 = reinterpret_cast< PyOSISHTMLHREF * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_RenderCallback, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyOSISHTMLHREF_setCallback" "', argument " "2"" of type '" "RenderCallback *""'"); 
  }
  arg2 = reinterpret_cast< RenderCallback * >(argp2);
  {
    try {
      (arg1)->setCallback(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PyOSISHTMLHREF_call(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PyOSISHTMLHREF *arg1 = 0 ;
  sword::SWBuf *arg2 = 0 ;
  char *arg3 = 0 ;
  sword::BasicFilterUserData *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PyObject *swig_obj[4] ;
  ReturnSuccess result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "PyOSISHTMLHREF_call", 4, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PyOSISHTMLHREF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyOSISHTMLHREF_call" "', argument " "1"" of type '" "PyOSISHTMLHREF *""'"); 
  }
  arg1 = reinterpret_cast< PyOSISHTMLHREF * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_sword__SWBuf,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyOSISHTMLHREF_call" "', argument " "2"" of type '" "sword::SWBuf &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "PyOSISHTMLHREF_call" "', argument " "2"" of type '" "sword::SWBuf &""'"); 
  }
  arg2 = reinterpret_cast< sword::SWBuf * >(argp2);
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PyOSISHTMLHREF_call" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_sword__BasicFilterUserData, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "PyOSISHTMLHREF_call" "', argument " "4"" of type '" "sword::BasicFilterUserData *""'"); 
  }
  arg4 = reinterpret_cast< sword::BasicFilterUserData * >(argp4);
  {
    try {
      result = (arg1)->call(*arg2,(char const *)arg3,arg4); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj((new ReturnSuccess(result)), SWIGTYPE_p_ReturnSuccess, SWIG_POINTER_OWN |  0 );
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return resultobj;
fail:
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return NULL;
}


SWIGINTERN PyObject *PyOSISHTMLHREF_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_PyOSISHTMLHREF, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *PyOSISHTMLHREF_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_PyThMLHTMLHREF_removeTokenSubstitute(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PyThMLHTMLHREF *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "PyThMLHTMLHREF_removeTokenSubstitute", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PyThMLHTMLHREF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyThMLHTMLHREF_removeTokenSubstitute" "', argument " "1"" of type '" "PyThMLHTMLHREF *""'"); 
  }
  arg1 = reinterpret_cast< PyThMLHTMLHREF * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyThMLHTMLHREF_removeTokenSubstitute" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    try {
      (arg1)->removeTokenSubstitute((char const *)arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_PyThMLHTMLHREF_addTokenSubstitute(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PyThMLHTMLHREF *arg1 = 0 ;
  char *arg2 = 0 ;
  char *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "PyThMLHTMLHREF_addTokenSubstitute", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PyThMLHTMLHREF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyThMLHTMLHREF_addTokenSubstitute" "', argument " "1"" of type '" "PyThMLHTMLHREF *""'"); 
  }
  arg1 = reinterpret_cast< PyThMLHTMLHREF * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyThMLHTMLHREF_addTokenSubstitute" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PyThMLHTMLHREF_addTokenSubstitute" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  {
    try {
      (arg1)->addTokenSubstitute((char const *)arg2,(char const *)arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_PyThMLHTMLHREF_addAllowedEscapeString(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PyThMLHTMLHREF *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "PyThMLHTMLHREF_addAllowedEscapeString", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PyThMLHTMLHREF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyThMLHTMLHREF_addAllowedEscapeString" "', argument " "1"" of type '" "PyThMLHTMLHREF *""'"); 
  }
  arg1 = reinterpret_cast< PyThMLHTMLHREF * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyThMLHTMLHREF_addAllowedEscapeString" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    try {
      (arg1)->addAllowedEscapeString((char const *)arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_PyThMLHTMLHREF_removeAllowedEscapeString(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PyThMLHTMLHREF *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "PyThMLHTMLHREF_removeAllowedEscapeString", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PyThMLHTMLHREF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyThMLHTMLHREF_removeAllowedEscapeString" "', argument " "1"" of type '" "PyThMLHTMLHREF *""'"); 
  }
  arg1 = reinterpret_cast< PyThMLHTMLHREF * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyThMLHTMLHREF_removeAllowedEscapeString" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    try {
      (arg1)->removeAllowedEscapeString((char const *)arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PyThMLHTMLHREF(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  RenderCallback *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  PyThMLHTMLHREF *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_RenderCallback, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PyThMLHTMLHREF" "', argument " "1"" of type '" "RenderCallback *""'"); 
  }
  arg1 = reinterpret_cast< RenderCallback * >(argp1);
  {
    try {
      result = (PyThMLHTMLHREF *)new PyThMLHTMLHREF(arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_PyThMLHTMLHREF, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PyThMLHTMLHREF_getData(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::BasicFilterUserData *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ThMLData *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__BasicFilterUserData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyThMLHTMLHREF_getData" "', argument " "1"" of type '" "sword::BasicFilterUserData *""'"); 
  }
  arg1 = reinterpret_cast< sword::BasicFilterUserData * >(argp1);
  {
    try {
      result = (ThMLData *)PyThMLHTMLHREF::getData(arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ThMLData, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_PyThMLHTMLHREF(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PyThMLHTMLHREF *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PyThMLHTMLHREF, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyThMLHTMLHREF" "', argument " "1"" of type '" "PyThMLHTMLHREF *""'"); 
  }
  arg1 = reinterpret_cast< PyThMLHTMLHREF * >(argp1);
  {
    try {
      delete arg1; 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PyThMLHTMLHREF_delCallback(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PyThMLHTMLHREF *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PyThMLHTMLHREF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyThMLHTMLHREF_delCallback" "', argument " "1"" of type '" "PyThMLHTMLHREF *""'"); 
  }
  arg1 = reinterpret_cast< PyThMLHTMLHREF * >(argp1);
  {
    try {
      (arg1)->delCallback(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PyThMLHTMLHREF_setCallback(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PyThMLHTMLHREF *arg1 = 0 ;
  RenderCallback *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "PyThMLHTMLHREF_setCallback", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PyThMLHTMLHREF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyThMLHTMLHREF_setCallback" "', argument " "1"" of type '" "PyThMLHTMLHREF *""'"); 
  }
  arg1 = reinterpret_cast< PyThMLHTMLHREF * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_RenderCallback, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyThMLHTMLHREF_setCallback" "', argument " "2"" of type '" "RenderCallback *""'"); 
  }
  arg2 = reinterpret_cast< RenderCallback * >(argp2);
  {
    try {
      (arg1)->setCallback(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PyThMLHTMLHREF_call(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PyThMLHTMLHREF *arg1 = 0 ;
  sword::SWBuf *arg2 = 0 ;
  char *arg3 = 0 ;
  sword::BasicFilterUserData *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PyObject *swig_obj[4] ;
  ReturnSuccess result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "PyThMLHTMLHREF_call", 4, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PyThMLHTMLHREF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyThMLHTMLHREF_call" "', argument " "1"" of type '" "PyThMLHTMLHREF *""'"); 
  }
  arg1 = reinterpret_cast< PyThMLHTMLHREF * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_sword__SWBuf,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyThMLHTMLHREF_call" "', argument " "2"" of type '" "sword::SWBuf &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "PyThMLHTMLHREF_call" "', argument " "2"" of type '" "sword::SWBuf &""'"); 
  }
  arg2 = reinterpret_cast< sword::SWBuf * >(argp2);
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PyThMLHTMLHREF_call" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_sword__BasicFilterUserData, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "PyThMLHTMLHREF_call" "', argument " "4"" of type '" "sword::BasicFilterUserData *""'"); 
  }
  arg4 = reinterpret_cast< sword::BasicFilterUserData * >(argp4);
  {
    try {
      result = (arg1)->call(*arg2,(char const *)arg3,arg4); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj((new ReturnSuccess(result)), SWIGTYPE_p_ReturnSuccess, SWIG_POINTER_OWN |  0 );
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return resultobj;
fail:
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return NULL;
}


SWIGINTERN PyObject *PyThMLHTMLHREF_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_PyThMLHTMLHREF, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *PyThMLHTMLHREF_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_OSISData_osisQToTick_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  OSISData *arg1 = 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "OSISData_osisQToTick_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OSISData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OSISData_osisQToTick_set" "', argument " "1"" of type '" "OSISData *""'"); 
  }
  arg1 = reinterpret_cast< OSISData * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "OSISData_osisQToTick_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->osisQToTick = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_OSISData_osisQToTick_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  OSISData *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OSISData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OSISData_osisQToTick_get" "', argument " "1"" of type '" "OSISData *""'"); 
  }
  arg1 = reinterpret_cast< OSISData * >(argp1);
  result = (bool) ((arg1)->osisQToTick);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_OSISData_inBold_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  OSISData *arg1 = 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "OSISData_inBold_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OSISData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OSISData_inBold_set" "', argument " "1"" of type '" "OSISData *""'"); 
  }
  arg1 = reinterpret_cast< OSISData * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "OSISData_inBold_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->inBold = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_OSISData_inBold_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  OSISData *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OSISData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OSISData_inBold_get" "', argument " "1"" of type '" "OSISData *""'"); 
  }
  arg1 = reinterpret_cast< OSISData * >(argp1);
  result = (bool) ((arg1)->inBold);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_OSISData_inXRefNote_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  OSISData *arg1 = 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "OSISData_inXRefNote_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OSISData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OSISData_inXRefNote_set" "', argument " "1"" of type '" "OSISData *""'"); 
  }
  arg1 = reinterpret_cast< OSISData * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "OSISData_inXRefNote_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->inXRefNote = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_OSISData_inXRefNote_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  OSISData *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OSISData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OSISData_inXRefNote_get" "', argument " "1"" of type '" "OSISData *""'"); 
  }
  arg1 = reinterpret_cast< OSISData * >(argp1);
  result = (bool) ((arg1)->inXRefNote);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_OSISData_isBiblicalText_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  OSISData *arg1 = 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "OSISData_isBiblicalText_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OSISData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OSISData_isBiblicalText_set" "', argument " "1"" of type '" "OSISData *""'"); 
  }
  arg1 = reinterpret_cast< OSISData * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "OSISData_isBiblicalText_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->isBiblicalText = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_OSISData_isBiblicalText_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  OSISData *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OSISData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OSISData_isBiblicalText_get" "', argument " "1"" of type '" "OSISData *""'"); 
  }
  arg1 = reinterpret_cast< OSISData * >(argp1);
  result = (bool) ((arg1)->isBiblicalText);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_OSISData_suspendLevel_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  OSISData *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "OSISData_suspendLevel_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OSISData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OSISData_suspendLevel_set" "', argument " "1"" of type '" "OSISData *""'"); 
  }
  arg1 = reinterpret_cast< OSISData * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "OSISData_suspendLevel_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  if (arg1) (arg1)->suspendLevel = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_OSISData_suspendLevel_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  OSISData *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OSISData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OSISData_suspendLevel_get" "', argument " "1"" of type '" "OSISData *""'"); 
  }
  arg1 = reinterpret_cast< OSISData * >(argp1);
  result = (int) ((arg1)->suspendLevel);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_OSISData_wordsOfChristStart_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  OSISData *arg1 = 0 ;
  sword::SWBuf *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "OSISData_wordsOfChristStart_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OSISData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OSISData_wordsOfChristStart_set" "', argument " "1"" of type '" "OSISData *""'"); 
  }
  arg1 = reinterpret_cast< OSISData * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_sword__SWBuf, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "OSISData_wordsOfChristStart_set" "', argument " "2"" of type '" "sword::SWBuf *""'"); 
  }
  arg2 = reinterpret_cast< sword::SWBuf * >(argp2);
  if (arg1) (arg1)->wordsOfChristStart = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_OSISData_wordsOfChristStart_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  OSISData *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  sword::SWBuf *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OSISData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OSISData_wordsOfChristStart_get" "', argument " "1"" of type '" "OSISData *""'"); 
  }
  arg1 = reinterpret_cast< OSISData * >(argp1);
  result = (sword::SWBuf *)& ((arg1)->wordsOfChristStart);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__SWBuf, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_OSISData_wordsOfChristEnd_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  OSISData *arg1 = 0 ;
  sword::SWBuf *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "OSISData_wordsOfChristEnd_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OSISData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OSISData_wordsOfChristEnd_set" "', argument " "1"" of type '" "OSISData *""'"); 
  }
  arg1 = reinterpret_cast< OSISData * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_sword__SWBuf, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "OSISData_wordsOfChristEnd_set" "', argument " "2"" of type '" "sword::SWBuf *""'"); 
  }
  arg2 = reinterpret_cast< sword::SWBuf * >(argp2);
  if (arg1) (arg1)->wordsOfChristEnd = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_OSISData_wordsOfChristEnd_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  OSISData *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  sword::SWBuf *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OSISData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OSISData_wordsOfChristEnd_get" "', argument " "1"" of type '" "OSISData *""'"); 
  }
  arg1 = reinterpret_cast< OSISData * >(argp1);
  result = (sword::SWBuf *)& ((arg1)->wordsOfChristEnd);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__SWBuf, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_OSISData_lastTransChange_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  OSISData *arg1 = 0 ;
  sword::SWBuf *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "OSISData_lastTransChange_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OSISData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OSISData_lastTransChange_set" "', argument " "1"" of type '" "OSISData *""'"); 
  }
  arg1 = reinterpret_cast< OSISData * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_sword__SWBuf, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "OSISData_lastTransChange_set" "', argument " "2"" of type '" "sword::SWBuf *""'"); 
  }
  arg2 = reinterpret_cast< sword::SWBuf * >(argp2);
  if (arg1) (arg1)->lastTransChange = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_OSISData_lastTransChange_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  OSISData *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  sword::SWBuf *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OSISData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OSISData_lastTransChange_get" "', argument " "1"" of type '" "OSISData *""'"); 
  }
  arg1 = reinterpret_cast< OSISData * >(argp1);
  result = (sword::SWBuf *)& ((arg1)->lastTransChange);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__SWBuf, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_OSISData_w_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  OSISData *arg1 = 0 ;
  sword::SWBuf *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "OSISData_w_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OSISData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OSISData_w_set" "', argument " "1"" of type '" "OSISData *""'"); 
  }
  arg1 = reinterpret_cast< OSISData * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_sword__SWBuf, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "OSISData_w_set" "', argument " "2"" of type '" "sword::SWBuf *""'"); 
  }
  arg2 = reinterpret_cast< sword::SWBuf * >(argp2);
  if (arg1) (arg1)->w = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_OSISData_w_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  OSISData *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  sword::SWBuf *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OSISData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OSISData_w_get" "', argument " "1"" of type '" "OSISData *""'"); 
  }
  arg1 = reinterpret_cast< OSISData * >(argp1);
  result = (sword::SWBuf *)& ((arg1)->w);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__SWBuf, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_OSISData_fn_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  OSISData *arg1 = 0 ;
  sword::SWBuf *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "OSISData_fn_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OSISData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OSISData_fn_set" "', argument " "1"" of type '" "OSISData *""'"); 
  }
  arg1 = reinterpret_cast< OSISData * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_sword__SWBuf, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "OSISData_fn_set" "', argument " "2"" of type '" "sword::SWBuf *""'"); 
  }
  arg2 = reinterpret_cast< sword::SWBuf * >(argp2);
  if (arg1) (arg1)->fn = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_OSISData_fn_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  OSISData *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  sword::SWBuf *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OSISData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OSISData_fn_get" "', argument " "1"" of type '" "OSISData *""'"); 
  }
  arg1 = reinterpret_cast< OSISData * >(argp1);
  result = (sword::SWBuf *)& ((arg1)->fn);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__SWBuf, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_OSISData_version_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  OSISData *arg1 = 0 ;
  sword::SWBuf *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "OSISData_version_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OSISData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OSISData_version_set" "', argument " "1"" of type '" "OSISData *""'"); 
  }
  arg1 = reinterpret_cast< OSISData * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_sword__SWBuf, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "OSISData_version_set" "', argument " "2"" of type '" "sword::SWBuf *""'"); 
  }
  arg2 = reinterpret_cast< sword::SWBuf * >(argp2);
  if (arg1) (arg1)->version = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_OSISData_version_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  OSISData *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  sword::SWBuf *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OSISData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OSISData_version_get" "', argument " "1"" of type '" "OSISData *""'"); 
  }
  arg1 = reinterpret_cast< OSISData * >(argp1);
  result = (sword::SWBuf *)& ((arg1)->version);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__SWBuf, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_OSISData(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  OSISData *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OSISData, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_OSISData" "', argument " "1"" of type '" "OSISData *""'"); 
  }
  arg1 = reinterpret_cast< OSISData * >(argp1);
  {
    try {
      delete arg1; 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *OSISData_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_OSISData, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_ThMLData_inscriptRef_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ThMLData *arg1 = 0 ;
  sword::SWBuf *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ThMLData_inscriptRef_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ThMLData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ThMLData_inscriptRef_set" "', argument " "1"" of type '" "ThMLData *""'"); 
  }
  arg1 = reinterpret_cast< ThMLData * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_sword__SWBuf, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ThMLData_inscriptRef_set" "', argument " "2"" of type '" "sword::SWBuf *""'"); 
  }
  arg2 = reinterpret_cast< sword::SWBuf * >(argp2);
  if (arg1) (arg1)->inscriptRef = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ThMLData_inscriptRef_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ThMLData *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  sword::SWBuf *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ThMLData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ThMLData_inscriptRef_get" "', argument " "1"" of type '" "ThMLData *""'"); 
  }
  arg1 = reinterpret_cast< ThMLData * >(argp1);
  result = (sword::SWBuf *)& ((arg1)->inscriptRef);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__SWBuf, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ThMLData_inSecHead_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ThMLData *arg1 = 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ThMLData_inSecHead_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ThMLData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ThMLData_inSecHead_set" "', argument " "1"" of type '" "ThMLData *""'"); 
  }
  arg1 = reinterpret_cast< ThMLData * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ThMLData_inSecHead_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->inSecHead = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ThMLData_inSecHead_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ThMLData *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ThMLData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ThMLData_inSecHead_get" "', argument " "1"" of type '" "ThMLData *""'"); 
  }
  arg1 = reinterpret_cast< ThMLData * >(argp1);
  result = (bool) ((arg1)->inSecHead);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ThMLData_isBiblicalText_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ThMLData *arg1 = 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ThMLData_isBiblicalText_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ThMLData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ThMLData_isBiblicalText_set" "', argument " "1"" of type '" "ThMLData *""'"); 
  }
  arg1 = reinterpret_cast< ThMLData * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ThMLData_isBiblicalText_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->isBiblicalText = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ThMLData_isBiblicalText_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ThMLData *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ThMLData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ThMLData_isBiblicalText_get" "', argument " "1"" of type '" "ThMLData *""'"); 
  }
  arg1 = reinterpret_cast< ThMLData * >(argp1);
  result = (bool) ((arg1)->isBiblicalText);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ThMLData_version_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ThMLData *arg1 = 0 ;
  sword::SWBuf *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ThMLData_version_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ThMLData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ThMLData_version_set" "', argument " "1"" of type '" "ThMLData *""'"); 
  }
  arg1 = reinterpret_cast< ThMLData * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_sword__SWBuf, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ThMLData_version_set" "', argument " "2"" of type '" "sword::SWBuf *""'"); 
  }
  arg2 = reinterpret_cast< sword::SWBuf * >(argp2);
  if (arg1) (arg1)->version = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ThMLData_version_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ThMLData *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  sword::SWBuf *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ThMLData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ThMLData_version_get" "', argument " "1"" of type '" "ThMLData *""'"); 
  }
  arg1 = reinterpret_cast< ThMLData * >(argp1);
  result = (sword::SWBuf *)& ((arg1)->version);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__SWBuf, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ThMLData_startTag_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ThMLData *arg1 = 0 ;
  sword::XMLTag *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ThMLData_startTag_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ThMLData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ThMLData_startTag_set" "', argument " "1"" of type '" "ThMLData *""'"); 
  }
  arg1 = reinterpret_cast< ThMLData * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_sword__XMLTag, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ThMLData_startTag_set" "', argument " "2"" of type '" "sword::XMLTag *""'"); 
  }
  arg2 = reinterpret_cast< sword::XMLTag * >(argp2);
  if (arg1) (arg1)->startTag = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ThMLData_startTag_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ThMLData *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  sword::XMLTag *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ThMLData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ThMLData_startTag_get" "', argument " "1"" of type '" "ThMLData *""'"); 
  }
  arg1 = reinterpret_cast< ThMLData * >(argp1);
  result = (sword::XMLTag *)& ((arg1)->startTag);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__XMLTag, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ThMLData(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ThMLData *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ThMLData, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ThMLData" "', argument " "1"" of type '" "ThMLData *""'"); 
  }
  arg1 = reinterpret_cast< ThMLData * >(argp1);
  {
    try {
      delete arg1; 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ThMLData_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ThMLData, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_SWSearcher_mod_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SWSearcher *arg1 = 0 ;
  sword::SWModule *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SWSearcher_mod_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SWSearcher, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWSearcher_mod_set" "', argument " "1"" of type '" "SWSearcher *""'"); 
  }
  arg1 = reinterpret_cast< SWSearcher * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_sword__SWModule, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SWSearcher_mod_set" "', argument " "2"" of type '" "sword::SWModule *""'"); 
  }
  arg2 = reinterpret_cast< sword::SWModule * >(argp2);
  if (arg1) (arg1)->mod = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWSearcher_mod_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SWSearcher *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  sword::SWModule *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SWSearcher, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWSearcher_mod_get" "', argument " "1"" of type '" "SWSearcher *""'"); 
  }
  arg1 = reinterpret_cast< SWSearcher * >(argp1);
  result = (sword::SWModule *) ((arg1)->mod);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__SWModule, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWSearcher_percent_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SWSearcher *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SWSearcher_percent_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SWSearcher, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWSearcher_percent_set" "', argument " "1"" of type '" "SWSearcher *""'"); 
  }
  arg1 = reinterpret_cast< SWSearcher * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SWSearcher_percent_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  if (arg1) (arg1)->percent = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWSearcher_percent_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SWSearcher *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SWSearcher, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWSearcher_percent_get" "', argument " "1"" of type '" "SWSearcher *""'"); 
  }
  arg1 = reinterpret_cast< SWSearcher * >(argp1);
  result = (int) ((arg1)->percent);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWSearcher_Callback(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  char arg1 ;
  void *arg2 = 0 ;
  char val1 ;
  int ecode1 = 0 ;
  int res2 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SWSearcher_Callback", 2, 2, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_char(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SWSearcher_Callback" "', argument " "1"" of type '" "char""'");
  } 
  arg1 = static_cast< char >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1],SWIG_as_voidptrptr(&arg2), 0, 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SWSearcher_Callback" "', argument " "2"" of type '" "void *""'"); 
  }
  {
    try {
      SWSearcher::Callback(arg1,arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWSearcher_PercentFunction(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SWSearcher *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SWSearcher_PercentFunction", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SWSearcher, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWSearcher_PercentFunction" "', argument " "1"" of type '" "SWSearcher *""'"); 
  }
  arg1 = reinterpret_cast< SWSearcher * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SWSearcher_PercentFunction" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          (arg1)->SWSearcher::PercentFunction(arg2);
        } else {
          (arg1)->PercentFunction(arg2);
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SWSearcher(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PyObject *arg1 = 0 ;
  sword::SWModule *arg2 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SWSearcher *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SWSearcher", 2, 2, swig_obj)) SWIG_fail;
  arg1 = swig_obj[0];
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_sword__SWModule, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_SWSearcher" "', argument " "2"" of type '" "sword::SWModule *""'"); 
  }
  arg2 = reinterpret_cast< sword::SWModule * >(argp2);
  {
    try {
      if ( arg1 != Py_None ) {
        /* subclassed */
        result = (SWSearcher *)new SwigDirector_SWSearcher(arg1,arg2); 
      } else {
        result = (SWSearcher *)new SWSearcher(arg2); 
      }
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SWSearcher, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SWSearcher(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SWSearcher *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SWSearcher, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SWSearcher" "', argument " "1"" of type '" "SWSearcher *""'"); 
  }
  arg1 = reinterpret_cast< SWSearcher * >(argp1);
  {
    try {
      delete arg1; 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWSearcher_GetPercent(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SWSearcher *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SWSearcher, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWSearcher_GetPercent" "', argument " "1"" of type '" "SWSearcher *""'"); 
  }
  arg1 = reinterpret_cast< SWSearcher * >(argp1);
  {
    try {
      result = (int)(arg1)->GetPercent(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWSearcher_isSearchSupported__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SWSearcher *arg1 = 0 ;
  char *arg2 = 0 ;
  int arg3 ;
  int arg4 ;
  sword::SWKey *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  bool result;
  
  (void)self;
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SWSearcher, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWSearcher_isSearchSupported" "', argument " "1"" of type '" "SWSearcher *""'"); 
  }
  arg1 = reinterpret_cast< SWSearcher * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SWSearcher_isSearchSupported" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SWSearcher_isSearchSupported" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SWSearcher_isSearchSupported" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5,SWIGTYPE_p_sword__SWKey, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "SWSearcher_isSearchSupported" "', argument " "5"" of type '" "sword::SWKey *""'"); 
  }
  arg5 = reinterpret_cast< sword::SWKey * >(argp5);
  {
    try {
      result = (bool)(arg1)->isSearchSupported((char const *)arg2,arg3,arg4,arg5); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWSearcher_isSearchSupported__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SWSearcher *arg1 = 0 ;
  char *arg2 = 0 ;
  int arg3 ;
  int arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  bool result;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SWSearcher, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWSearcher_isSearchSupported" "', argument " "1"" of type '" "SWSearcher *""'"); 
  }
  arg1 = reinterpret_cast< SWSearcher * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SWSearcher_isSearchSupported" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SWSearcher_isSearchSupported" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SWSearcher_isSearchSupported" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  {
    try {
      result = (bool)(arg1)->isSearchSupported((char const *)arg2,arg3,arg4); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWSearcher_isSearchSupported__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SWSearcher *arg1 = 0 ;
  char *arg2 = 0 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  bool result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SWSearcher, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWSearcher_isSearchSupported" "', argument " "1"" of type '" "SWSearcher *""'"); 
  }
  arg1 = reinterpret_cast< SWSearcher * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SWSearcher_isSearchSupported" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SWSearcher_isSearchSupported" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  {
    try {
      result = (bool)(arg1)->isSearchSupported((char const *)arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWSearcher_isSearchSupported__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SWSearcher *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  bool result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SWSearcher, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWSearcher_isSearchSupported" "', argument " "1"" of type '" "SWSearcher *""'"); 
  }
  arg1 = reinterpret_cast< SWSearcher * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SWSearcher_isSearchSupported" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    try {
      result = (bool)(arg1)->isSearchSupported((char const *)arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWSearcher_isSearchSupported(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SWSearcher_isSearchSupported", 0, 5, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SWSearcher, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SWSearcher_isSearchSupported__SWIG_3(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SWSearcher, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SWSearcher_isSearchSupported__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SWSearcher, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_SWSearcher_isSearchSupported__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SWSearcher, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_sword__SWKey, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_SWSearcher_isSearchSupported__SWIG_0(self, argc, argv);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SWSearcher_isSearchSupported'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SWSearcher::isSearchSupported(char const *,int,int,sword::SWKey *)\n"
    "    SWSearcher::isSearchSupported(char const *,int,int)\n"
    "    SWSearcher::isSearchSupported(char const *,int)\n"
    "    SWSearcher::isSearchSupported(char const *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SWSearcher_doSearch__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SWSearcher *arg1 = 0 ;
  char *arg2 = 0 ;
  int arg3 ;
  int arg4 ;
  sword::SWKey *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  sword::ListKey *result = 0 ;
  
  (void)self;
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SWSearcher, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWSearcher_doSearch" "', argument " "1"" of type '" "SWSearcher *""'"); 
  }
  arg1 = reinterpret_cast< SWSearcher * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SWSearcher_doSearch" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SWSearcher_doSearch" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SWSearcher_doSearch" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5,SWIGTYPE_p_sword__SWKey, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "SWSearcher_doSearch" "', argument " "5"" of type '" "sword::SWKey *""'"); 
  }
  arg5 = reinterpret_cast< sword::SWKey * >(argp5);
  {
    try {
      result = (sword::ListKey *) &(arg1)->doSearch((char const *)arg2,arg3,arg4,arg5); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__ListKey, 0 |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWSearcher_doSearch__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SWSearcher *arg1 = 0 ;
  char *arg2 = 0 ;
  int arg3 ;
  int arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  sword::ListKey *result = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SWSearcher, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWSearcher_doSearch" "', argument " "1"" of type '" "SWSearcher *""'"); 
  }
  arg1 = reinterpret_cast< SWSearcher * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SWSearcher_doSearch" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SWSearcher_doSearch" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SWSearcher_doSearch" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  {
    try {
      result = (sword::ListKey *) &(arg1)->doSearch((char const *)arg2,arg3,arg4); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__ListKey, 0 |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWSearcher_doSearch__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SWSearcher *arg1 = 0 ;
  char *arg2 = 0 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  sword::ListKey *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SWSearcher, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWSearcher_doSearch" "', argument " "1"" of type '" "SWSearcher *""'"); 
  }
  arg1 = reinterpret_cast< SWSearcher * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SWSearcher_doSearch" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SWSearcher_doSearch" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  {
    try {
      result = (sword::ListKey *) &(arg1)->doSearch((char const *)arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__ListKey, 0 |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWSearcher_doSearch__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SWSearcher *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  sword::ListKey *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SWSearcher, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWSearcher_doSearch" "', argument " "1"" of type '" "SWSearcher *""'"); 
  }
  arg1 = reinterpret_cast< SWSearcher * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SWSearcher_doSearch" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    try {
      result = (sword::ListKey *) &(arg1)->doSearch((char const *)arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__ListKey, 0 |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWSearcher_doSearch(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SWSearcher_doSearch", 0, 5, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SWSearcher, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SWSearcher_doSearch__SWIG_3(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SWSearcher, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SWSearcher_doSearch__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SWSearcher, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_SWSearcher_doSearch__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SWSearcher, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_sword__SWKey, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_SWSearcher_doSearch__SWIG_0(self, argc, argv);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SWSearcher_doSearch'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SWSearcher::doSearch(char const *,int,int,sword::SWKey *)\n"
    "    SWSearcher::doSearch(char const *,int,int)\n"
    "    SWSearcher::doSearch(char const *,int)\n"
    "    SWSearcher::doSearch(char const *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SWSearcher_TerminateSearch(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SWSearcher *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SWSearcher, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWSearcher_TerminateSearch" "', argument " "1"" of type '" "SWSearcher *""'"); 
  }
  arg1 = reinterpret_cast< SWSearcher * >(argp1);
  {
    try {
      (arg1)->TerminateSearch(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_disown_SWSearcher(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SWSearcher *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SWSearcher, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "disown_SWSearcher" "', argument " "1"" of type '" "SWSearcher *""'"); 
  }
  arg1 = reinterpret_cast< SWSearcher * >(argp1);
  {
    Swig::Director *director = SWIG_DIRECTOR_CAST(arg1);
    if (director) director->swig_disown();
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SWSearcher_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SWSearcher, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SWSearcher_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN int Swig_var_SWLog_LOG_ERROR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SWLog_LOG_ERROR is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SWLog_LOG_ERROR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(sword::SWLog::LOG_ERROR));
  return pyobj;
}


SWIGINTERN int Swig_var_SWLog_LOG_WARN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SWLog_LOG_WARN is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SWLog_LOG_WARN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(sword::SWLog::LOG_WARN));
  return pyobj;
}


SWIGINTERN int Swig_var_SWLog_LOG_INFO_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SWLog_LOG_INFO is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SWLog_LOG_INFO_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(sword::SWLog::LOG_INFO));
  return pyobj;
}


SWIGINTERN int Swig_var_SWLog_LOG_TIMEDINFO_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SWLog_LOG_TIMEDINFO is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SWLog_LOG_TIMEDINFO_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(sword::SWLog::LOG_TIMEDINFO));
  return pyobj;
}


SWIGINTERN int Swig_var_SWLog_LOG_DEBUG_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SWLog_LOG_DEBUG is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SWLog_LOG_DEBUG_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(sword::SWLog::LOG_DEBUG));
  return pyobj;
}


SWIGINTERN PyObject *_wrap_SWLog_getSystemLog(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWLog *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SWLog_getSystemLog", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (sword::SWLog *)sword::SWLog::getSystemLog(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__SWLog, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWLog_setSystemLog(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWLog *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWLog, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWLog_setSystemLog" "', argument " "1"" of type '" "sword::SWLog *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWLog * >(argp1);
  {
    try {
      sword::SWLog::setSystemLog(arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SWLog(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWLog *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SWLog", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (sword::SWLog *)new sword::SWLog(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__SWLog, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SWLog(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWLog *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWLog, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SWLog" "', argument " "1"" of type '" "sword::SWLog *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWLog * >(argp1);
  {
    try {
      delete arg1; 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWLog_setLogLevel(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWLog *arg1 = 0 ;
  char arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SWLog_setLogLevel", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWLog, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWLog_setLogLevel" "', argument " "1"" of type '" "sword::SWLog *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWLog * >(argp1);
  ecode2 = SWIG_AsVal_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SWLog_setLogLevel" "', argument " "2"" of type '" "char""'");
  } 
  arg2 = static_cast< char >(val2);
  {
    try {
      (arg1)->setLogLevel(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWLog_getLogLevel(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWLog *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWLog, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWLog_getLogLevel" "', argument " "1"" of type '" "sword::SWLog const *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWLog * >(argp1);
  {
    try {
      result = (char)((sword::SWLog const *)arg1)->getLogLevel(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_char(static_cast< char >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWLog_logWarning__varargs__(PyObject *self, PyObject *args, PyObject *varargs) {
  PyObject *resultobj = 0;
  sword::SWLog *arg1 = 0 ;
  char *arg2 = 0 ;
  void *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  (void)self;
  if (!PyArg_UnpackTuple(args, "SWLog_logWarning", 2, 2, &obj0, &obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_sword__SWLog, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWLog_logWarning" "', argument " "1"" of type '" "sword::SWLog const *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWLog * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SWLog_logWarning" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    try {
      ((sword::SWLog const *)arg1)->logWarning((char const *)arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWLog_logWarning(PyObject *self, PyObject *args) {
  PyObject *resultobj;
  PyObject *varargs;
  PyObject *newargs;
  
  newargs = PyTuple_GetSlice(args, 0, 2);
  varargs = PyTuple_GetSlice(args, 2, PyTuple_Size(args));
  resultobj = _wrap_SWLog_logWarning__varargs__(NULL, newargs, varargs);
  SWIG_Py_XDECREF(newargs);
  SWIG_Py_XDECREF(varargs);
  return resultobj;
}


SWIGINTERN PyObject *_wrap_SWLog_logError__varargs__(PyObject *self, PyObject *args, PyObject *varargs) {
  PyObject *resultobj = 0;
  sword::SWLog *arg1 = 0 ;
  char *arg2 = 0 ;
  void *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  (void)self;
  if (!PyArg_UnpackTuple(args, "SWLog_logError", 2, 2, &obj0, &obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_sword__SWLog, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWLog_logError" "', argument " "1"" of type '" "sword::SWLog const *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWLog * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SWLog_logError" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    try {
      ((sword::SWLog const *)arg1)->logError((char const *)arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWLog_logError(PyObject *self, PyObject *args) {
  PyObject *resultobj;
  PyObject *varargs;
  PyObject *newargs;
  
  newargs = PyTuple_GetSlice(args, 0, 2);
  varargs = PyTuple_GetSlice(args, 2, PyTuple_Size(args));
  resultobj = _wrap_SWLog_logError__varargs__(NULL, newargs, varargs);
  SWIG_Py_XDECREF(newargs);
  SWIG_Py_XDECREF(varargs);
  return resultobj;
}


SWIGINTERN PyObject *_wrap_SWLog_logInformation__varargs__(PyObject *self, PyObject *args, PyObject *varargs) {
  PyObject *resultobj = 0;
  sword::SWLog *arg1 = 0 ;
  char *arg2 = 0 ;
  void *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  (void)self;
  if (!PyArg_UnpackTuple(args, "SWLog_logInformation", 2, 2, &obj0, &obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_sword__SWLog, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWLog_logInformation" "', argument " "1"" of type '" "sword::SWLog const *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWLog * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SWLog_logInformation" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    try {
      ((sword::SWLog const *)arg1)->logInformation((char const *)arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWLog_logInformation(PyObject *self, PyObject *args) {
  PyObject *resultobj;
  PyObject *varargs;
  PyObject *newargs;
  
  newargs = PyTuple_GetSlice(args, 0, 2);
  varargs = PyTuple_GetSlice(args, 2, PyTuple_Size(args));
  resultobj = _wrap_SWLog_logInformation__varargs__(NULL, newargs, varargs);
  SWIG_Py_XDECREF(newargs);
  SWIG_Py_XDECREF(varargs);
  return resultobj;
}


SWIGINTERN PyObject *_wrap_SWLog_logDebug__varargs__(PyObject *self, PyObject *args, PyObject *varargs) {
  PyObject *resultobj = 0;
  sword::SWLog *arg1 = 0 ;
  char *arg2 = 0 ;
  void *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  (void)self;
  if (!PyArg_UnpackTuple(args, "SWLog_logDebug", 2, 2, &obj0, &obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_sword__SWLog, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWLog_logDebug" "', argument " "1"" of type '" "sword::SWLog const *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWLog * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SWLog_logDebug" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    try {
      ((sword::SWLog const *)arg1)->logDebug((char const *)arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWLog_logDebug(PyObject *self, PyObject *args) {
  PyObject *resultobj;
  PyObject *varargs;
  PyObject *newargs;
  
  newargs = PyTuple_GetSlice(args, 0, 2);
  varargs = PyTuple_GetSlice(args, 2, PyTuple_Size(args));
  resultobj = _wrap_SWLog_logDebug__varargs__(NULL, newargs, varargs);
  SWIG_Py_XDECREF(newargs);
  SWIG_Py_XDECREF(varargs);
  return resultobj;
}


SWIGINTERN PyObject *_wrap_SWLog_logMessage(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::SWLog *arg1 = 0 ;
  char *arg2 = 0 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SWLog_logMessage", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__SWLog, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWLog_logMessage" "', argument " "1"" of type '" "sword::SWLog const *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWLog * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SWLog_logMessage" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SWLog_logMessage" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          ((sword::SWLog const *)arg1)->sword::SWLog::logMessage((char const *)arg2,arg3);
        } else {
          ((sword::SWLog const *)arg1)->logMessage((char const *)arg2,arg3);
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWLog_logTimedInformation__varargs__(PyObject *self, PyObject *args, PyObject *varargs) {
  PyObject *resultobj = 0;
  sword::SWLog *arg1 = 0 ;
  char *arg2 = 0 ;
  void *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  (void)self;
  if (!PyArg_UnpackTuple(args, "SWLog_logTimedInformation", 2, 2, &obj0, &obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_sword__SWLog, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SWLog_logTimedInformation" "', argument " "1"" of type '" "sword::SWLog const *""'"); 
  }
  arg1 = reinterpret_cast< sword::SWLog * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SWLog_logTimedInformation" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    try {
      ((sword::SWLog const *)arg1)->logTimedInformation((char const *)arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SWLog_logTimedInformation(PyObject *self, PyObject *args) {
  PyObject *resultobj;
  PyObject *varargs;
  PyObject *newargs;
  
  newargs = PyTuple_GetSlice(args, 0, 2);
  varargs = PyTuple_GetSlice(args, 2, PyTuple_Size(args));
  resultobj = _wrap_SWLog_logTimedInformation__varargs__(NULL, newargs, varargs);
  SWIG_Py_XDECREF(newargs);
  SWIG_Py_XDECREF(varargs);
  return resultobj;
}


SWIGINTERN PyObject *SWLog_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_sword__SWLog, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SWLog_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_delete_StatusReporter(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::StatusReporter *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__StatusReporter, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_StatusReporter" "', argument " "1"" of type '" "sword::StatusReporter *""'"); 
  }
  arg1 = reinterpret_cast< sword::StatusReporter * >(argp1);
  {
    try {
      delete arg1; 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StatusReporter_preStatus(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::StatusReporter *arg1 = 0 ;
  long arg2 ;
  long arg3 ;
  char *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  long val2 ;
  int ecode2 = 0 ;
  long val3 ;
  int ecode3 = 0 ;
  int res4 ;
  char *buf4 = 0 ;
  int alloc4 = 0 ;
  PyObject *swig_obj[4] ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "StatusReporter_preStatus", 4, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__StatusReporter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StatusReporter_preStatus" "', argument " "1"" of type '" "sword::StatusReporter *""'"); 
  }
  arg1 = reinterpret_cast< sword::StatusReporter * >(argp1);
  ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StatusReporter_preStatus" "', argument " "2"" of type '" "long""'");
  } 
  arg2 = static_cast< long >(val2);
  ecode3 = SWIG_AsVal_long(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "StatusReporter_preStatus" "', argument " "3"" of type '" "long""'");
  } 
  arg3 = static_cast< long >(val3);
  res4 = SWIG_AsCharPtrAndSize(swig_obj[3], &buf4, NULL, &alloc4);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "StatusReporter_preStatus" "', argument " "4"" of type '" "char const *""'");
  }
  arg4 = reinterpret_cast< char * >(buf4);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          (arg1)->sword::StatusReporter::preStatus(arg2,arg3,(char const *)arg4);
        } else {
          (arg1)->preStatus(arg2,arg3,(char const *)arg4);
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
  return resultobj;
fail:
  if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_StatusReporter_update(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::StatusReporter *arg1 = 0 ;
  unsigned long arg2 ;
  unsigned long arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long val2 ;
  int ecode2 = 0 ;
  unsigned long val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "StatusReporter_update", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__StatusReporter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StatusReporter_update" "', argument " "1"" of type '" "sword::StatusReporter *""'"); 
  }
  arg1 = reinterpret_cast< sword::StatusReporter * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StatusReporter_update" "', argument " "2"" of type '" "unsigned long""'");
  } 
  arg2 = static_cast< unsigned long >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_long(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "StatusReporter_update" "', argument " "3"" of type '" "unsigned long""'");
  } 
  arg3 = static_cast< unsigned long >(val3);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          (arg1)->sword::StatusReporter::update(arg2,arg3);
        } else {
          (arg1)->update(arg2,arg3);
        } 
      }
      catch (Swig::DirectorException &e) {
        SWIG_fail; 
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_StatusReporter(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PyObject *arg1 = 0 ;
  PyObject *swig_obj[1] ;
  sword::StatusReporter *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  arg1 = swig_obj[0];
  {
    try {
      if ( arg1 != Py_None ) {
        /* subclassed */
        result = (sword::StatusReporter *)new SwigDirector_StatusReporter(arg1); 
      } else {
        result = (sword::StatusReporter *)new sword::StatusReporter(); 
      }
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__StatusReporter, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_disown_StatusReporter(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::StatusReporter *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__StatusReporter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "disown_StatusReporter" "', argument " "1"" of type '" "sword::StatusReporter *""'"); 
  }
  arg1 = reinterpret_cast< sword::StatusReporter * >(argp1);
  {
    Swig::Director *director = SWIG_DIRECTOR_CAST(arg1);
    if (director) director->swig_disown();
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *StatusReporter_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_sword__StatusReporter, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *StatusReporter_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_RemoteTransport__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  sword::StatusReporter *arg2 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  sword::RemoteTransport *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_RemoteTransport" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_sword__StatusReporter, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_RemoteTransport" "', argument " "2"" of type '" "sword::StatusReporter *""'"); 
  }
  arg2 = reinterpret_cast< sword::StatusReporter * >(argp2);
  {
    try {
      result = (sword::RemoteTransport *)new sword::RemoteTransport((char const *)arg1,arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__RemoteTransport, SWIG_POINTER_NEW |  0 );
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RemoteTransport__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  sword::RemoteTransport *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_RemoteTransport" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  {
    try {
      result = (sword::RemoteTransport *)new sword::RemoteTransport((char const *)arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__RemoteTransport, SWIG_POINTER_NEW |  0 );
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RemoteTransport(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_RemoteTransport", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_RemoteTransport__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_sword__StatusReporter, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_RemoteTransport__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_RemoteTransport'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    sword::RemoteTransport::RemoteTransport(char const *,sword::StatusReporter *)\n"
    "    sword::RemoteTransport::RemoteTransport(char const *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_RemoteTransport(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::RemoteTransport *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__RemoteTransport, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RemoteTransport" "', argument " "1"" of type '" "sword::RemoteTransport *""'"); 
  }
  arg1 = reinterpret_cast< sword::RemoteTransport * >(argp1);
  {
    try {
      delete arg1; 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RemoteTransport_getURL__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::RemoteTransport *arg1 = 0 ;
  char *arg2 = 0 ;
  char *arg3 = 0 ;
  sword::SWBuf *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  char result;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__RemoteTransport, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RemoteTransport_getURL" "', argument " "1"" of type '" "sword::RemoteTransport *""'"); 
  }
  arg1 = reinterpret_cast< sword::RemoteTransport * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RemoteTransport_getURL" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RemoteTransport_getURL" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_sword__SWBuf, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "RemoteTransport_getURL" "', argument " "4"" of type '" "sword::SWBuf *""'"); 
  }
  arg4 = reinterpret_cast< sword::SWBuf * >(argp4);
  {
    try {
      result = (char)(arg1)->getURL((char const *)arg2,(char const *)arg3,arg4); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_char(static_cast< char >(result));
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_RemoteTransport_getURL__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::RemoteTransport *arg1 = 0 ;
  char *arg2 = 0 ;
  char *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  char result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__RemoteTransport, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RemoteTransport_getURL" "', argument " "1"" of type '" "sword::RemoteTransport *""'"); 
  }
  arg1 = reinterpret_cast< sword::RemoteTransport * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RemoteTransport_getURL" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RemoteTransport_getURL" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  {
    try {
      result = (char)(arg1)->getURL((char const *)arg2,(char const *)arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_char(static_cast< char >(result));
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_RemoteTransport_getURL(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "RemoteTransport_getURL", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__RemoteTransport, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_RemoteTransport_getURL__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__RemoteTransport, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_sword__SWBuf, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_RemoteTransport_getURL__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'RemoteTransport_getURL'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    sword::RemoteTransport::getURL(char const *,char const *,sword::SWBuf *)\n"
    "    sword::RemoteTransport::getURL(char const *,char const *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_RemoteTransport_putURL__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::RemoteTransport *arg1 = 0 ;
  char *arg2 = 0 ;
  char *arg3 = 0 ;
  sword::SWBuf *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  char result;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__RemoteTransport, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RemoteTransport_putURL" "', argument " "1"" of type '" "sword::RemoteTransport *""'"); 
  }
  arg1 = reinterpret_cast< sword::RemoteTransport * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RemoteTransport_putURL" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RemoteTransport_putURL" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_sword__SWBuf, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "RemoteTransport_putURL" "', argument " "4"" of type '" "sword::SWBuf *""'"); 
  }
  arg4 = reinterpret_cast< sword::SWBuf * >(argp4);
  {
    try {
      result = (char)(arg1)->putURL((char const *)arg2,(char const *)arg3,arg4); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_char(static_cast< char >(result));
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_RemoteTransport_putURL__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::RemoteTransport *arg1 = 0 ;
  char *arg2 = 0 ;
  char *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  char result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__RemoteTransport, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RemoteTransport_putURL" "', argument " "1"" of type '" "sword::RemoteTransport *""'"); 
  }
  arg1 = reinterpret_cast< sword::RemoteTransport * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RemoteTransport_putURL" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RemoteTransport_putURL" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  {
    try {
      result = (char)(arg1)->putURL((char const *)arg2,(char const *)arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_char(static_cast< char >(result));
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_RemoteTransport_putURL(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "RemoteTransport_putURL", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__RemoteTransport, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_RemoteTransport_putURL__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__RemoteTransport, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_sword__SWBuf, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_RemoteTransport_putURL__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'RemoteTransport_putURL'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    sword::RemoteTransport::putURL(char const *,char const *,sword::SWBuf *)\n"
    "    sword::RemoteTransport::putURL(char const *,char const *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_RemoteTransport_copyDirectory(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::RemoteTransport *arg1 = 0 ;
  char *arg2 = 0 ;
  char *arg3 = 0 ;
  char *arg4 = 0 ;
  char *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  int res4 ;
  char *buf4 = 0 ;
  int alloc4 = 0 ;
  int res5 ;
  char *buf5 = 0 ;
  int alloc5 = 0 ;
  PyObject *swig_obj[5] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "RemoteTransport_copyDirectory", 5, 5, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__RemoteTransport, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RemoteTransport_copyDirectory" "', argument " "1"" of type '" "sword::RemoteTransport *""'"); 
  }
  arg1 = reinterpret_cast< sword::RemoteTransport * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RemoteTransport_copyDirectory" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RemoteTransport_copyDirectory" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  res4 = SWIG_AsCharPtrAndSize(swig_obj[3], &buf4, NULL, &alloc4);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "RemoteTransport_copyDirectory" "', argument " "4"" of type '" "char const *""'");
  }
  arg4 = reinterpret_cast< char * >(buf4);
  res5 = SWIG_AsCharPtrAndSize(swig_obj[4], &buf5, NULL, &alloc5);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "RemoteTransport_copyDirectory" "', argument " "5"" of type '" "char const *""'");
  }
  arg5 = reinterpret_cast< char * >(buf5);
  {
    try {
      result = (int)(arg1)->copyDirectory((char const *)arg2,(char const *)arg3,(char const *)arg4,(char const *)arg5); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
  if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
  if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
  return NULL;
}


SWIGINTERN PyObject *_wrap_RemoteTransport_getDirList(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::RemoteTransport *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  std::vector< sword::DirEntry,std::allocator< sword::DirEntry > > result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "RemoteTransport_getDirList", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__RemoteTransport, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RemoteTransport_getDirList" "', argument " "1"" of type '" "sword::RemoteTransport *""'"); 
  }
  arg1 = reinterpret_cast< sword::RemoteTransport * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RemoteTransport_getDirList" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    try {
      result = (arg1)->getDirList((char const *)arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = swig::from(static_cast< std::vector< sword::DirEntry,std::allocator< sword::DirEntry > > >(result));
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_RemoteTransport_setPassive(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::RemoteTransport *arg1 = 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "RemoteTransport_setPassive", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__RemoteTransport, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RemoteTransport_setPassive" "', argument " "1"" of type '" "sword::RemoteTransport *""'"); 
  }
  arg1 = reinterpret_cast< sword::RemoteTransport * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RemoteTransport_setPassive" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    try {
      (arg1)->setPassive(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RemoteTransport_setTimeoutMillis(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::RemoteTransport *arg1 = 0 ;
  long arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  long val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "RemoteTransport_setTimeoutMillis", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__RemoteTransport, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RemoteTransport_setTimeoutMillis" "', argument " "1"" of type '" "sword::RemoteTransport *""'"); 
  }
  arg1 = reinterpret_cast< sword::RemoteTransport * >(argp1);
  ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RemoteTransport_setTimeoutMillis" "', argument " "2"" of type '" "long""'");
  } 
  arg2 = static_cast< long >(val2);
  {
    try {
      (arg1)->setTimeoutMillis(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RemoteTransport_getTimeoutMillis(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::RemoteTransport *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  long result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__RemoteTransport, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RemoteTransport_getTimeoutMillis" "', argument " "1"" of type '" "sword::RemoteTransport *""'"); 
  }
  arg1 = reinterpret_cast< sword::RemoteTransport * >(argp1);
  {
    try {
      result = (long)(arg1)->getTimeoutMillis(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_long(static_cast< long >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RemoteTransport_isPassive(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::RemoteTransport *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__RemoteTransport, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RemoteTransport_isPassive" "', argument " "1"" of type '" "sword::RemoteTransport *""'"); 
  }
  arg1 = reinterpret_cast< sword::RemoteTransport * >(argp1);
  {
    try {
      result = (bool)(arg1)->isPassive(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RemoteTransport_setUser(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::RemoteTransport *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "RemoteTransport_setUser", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__RemoteTransport, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RemoteTransport_setUser" "', argument " "1"" of type '" "sword::RemoteTransport *""'"); 
  }
  arg1 = reinterpret_cast< sword::RemoteTransport * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RemoteTransport_setUser" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    try {
      (arg1)->setUser((char const *)arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_RemoteTransport_setPasswd(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::RemoteTransport *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "RemoteTransport_setPasswd", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__RemoteTransport, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RemoteTransport_setPasswd" "', argument " "1"" of type '" "sword::RemoteTransport *""'"); 
  }
  arg1 = reinterpret_cast< sword::RemoteTransport * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RemoteTransport_setPasswd" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    try {
      (arg1)->setPasswd((char const *)arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_RemoteTransport_setUnverifiedPeerAllowed(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::RemoteTransport *arg1 = 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "RemoteTransport_setUnverifiedPeerAllowed", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__RemoteTransport, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RemoteTransport_setUnverifiedPeerAllowed" "', argument " "1"" of type '" "sword::RemoteTransport *""'"); 
  }
  arg1 = reinterpret_cast< sword::RemoteTransport * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RemoteTransport_setUnverifiedPeerAllowed" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    try {
      (arg1)->setUnverifiedPeerAllowed(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RemoteTransport_isUnverifiedPeerAllowed(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::RemoteTransport *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__RemoteTransport, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RemoteTransport_isUnverifiedPeerAllowed" "', argument " "1"" of type '" "sword::RemoteTransport *""'"); 
  }
  arg1 = reinterpret_cast< sword::RemoteTransport * >(argp1);
  {
    try {
      result = (bool)(arg1)->isUnverifiedPeerAllowed(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RemoteTransport_terminate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::RemoteTransport *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__RemoteTransport, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RemoteTransport_terminate" "', argument " "1"" of type '" "sword::RemoteTransport *""'"); 
  }
  arg1 = reinterpret_cast< sword::RemoteTransport * >(argp1);
  {
    try {
      (arg1)->terminate(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *RemoteTransport_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_sword__RemoteTransport, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *RemoteTransport_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_InstallSource__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  char *arg2 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  sword::InstallSource *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_InstallSource" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_InstallSource" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    try {
      result = (sword::InstallSource *)new sword::InstallSource((char const *)arg1,(char const *)arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__InstallSource, SWIG_POINTER_NEW |  0 );
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_InstallSource__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  sword::InstallSource *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_InstallSource" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  {
    try {
      result = (sword::InstallSource *)new sword::InstallSource((char const *)arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__InstallSource, SWIG_POINTER_NEW |  0 );
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_InstallSource(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_InstallSource", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_InstallSource__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_InstallSource__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_InstallSource'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    sword::InstallSource::InstallSource(char const *,char const *)\n"
    "    sword::InstallSource::InstallSource(char const *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_InstallSource(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::InstallSource *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__InstallSource, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_InstallSource" "', argument " "1"" of type '" "sword::InstallSource *""'"); 
  }
  arg1 = reinterpret_cast< sword::InstallSource * >(argp1);
  {
    try {
      delete arg1; 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InstallSource_getConfEnt(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::InstallSource *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  sword::SWBuf result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__InstallSource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InstallSource_getConfEnt" "', argument " "1"" of type '" "sword::InstallSource *""'"); 
  }
  arg1 = reinterpret_cast< sword::InstallSource * >(argp1);
  {
    try {
      result = (arg1)->getConfEnt(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj((new sword::SWBuf(result)), SWIGTYPE_p_sword__SWBuf, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InstallSource_caption_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::InstallSource *arg1 = 0 ;
  sword::SWBuf *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "InstallSource_caption_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__InstallSource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InstallSource_caption_set" "', argument " "1"" of type '" "sword::InstallSource *""'"); 
  }
  arg1 = reinterpret_cast< sword::InstallSource * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_sword__SWBuf, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InstallSource_caption_set" "', argument " "2"" of type '" "sword::SWBuf *""'"); 
  }
  arg2 = reinterpret_cast< sword::SWBuf * >(argp2);
  if (arg1) (arg1)->caption = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InstallSource_caption_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::InstallSource *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  sword::SWBuf *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__InstallSource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InstallSource_caption_get" "', argument " "1"" of type '" "sword::InstallSource *""'"); 
  }
  arg1 = reinterpret_cast< sword::InstallSource * >(argp1);
  result = (sword::SWBuf *)& ((arg1)->caption);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__SWBuf, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InstallSource_source_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::InstallSource *arg1 = 0 ;
  sword::SWBuf *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "InstallSource_source_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__InstallSource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InstallSource_source_set" "', argument " "1"" of type '" "sword::InstallSource *""'"); 
  }
  arg1 = reinterpret_cast< sword::InstallSource * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_sword__SWBuf, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InstallSource_source_set" "', argument " "2"" of type '" "sword::SWBuf *""'"); 
  }
  arg2 = reinterpret_cast< sword::SWBuf * >(argp2);
  if (arg1) (arg1)->source = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InstallSource_source_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::InstallSource *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  sword::SWBuf *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__InstallSource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InstallSource_source_get" "', argument " "1"" of type '" "sword::InstallSource *""'"); 
  }
  arg1 = reinterpret_cast< sword::InstallSource * >(argp1);
  result = (sword::SWBuf *)& ((arg1)->source);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__SWBuf, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InstallSource_directory_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::InstallSource *arg1 = 0 ;
  sword::SWBuf *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "InstallSource_directory_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__InstallSource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InstallSource_directory_set" "', argument " "1"" of type '" "sword::InstallSource *""'"); 
  }
  arg1 = reinterpret_cast< sword::InstallSource * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_sword__SWBuf, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InstallSource_directory_set" "', argument " "2"" of type '" "sword::SWBuf *""'"); 
  }
  arg2 = reinterpret_cast< sword::SWBuf * >(argp2);
  if (arg1) (arg1)->directory = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InstallSource_directory_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::InstallSource *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  sword::SWBuf *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__InstallSource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InstallSource_directory_get" "', argument " "1"" of type '" "sword::InstallSource *""'"); 
  }
  arg1 = reinterpret_cast< sword::InstallSource * >(argp1);
  result = (sword::SWBuf *)& ((arg1)->directory);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__SWBuf, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InstallSource_u_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::InstallSource *arg1 = 0 ;
  sword::SWBuf *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "InstallSource_u_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__InstallSource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InstallSource_u_set" "', argument " "1"" of type '" "sword::InstallSource *""'"); 
  }
  arg1 = reinterpret_cast< sword::InstallSource * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_sword__SWBuf, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InstallSource_u_set" "', argument " "2"" of type '" "sword::SWBuf *""'"); 
  }
  arg2 = reinterpret_cast< sword::SWBuf * >(argp2);
  if (arg1) (arg1)->u = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InstallSource_u_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::InstallSource *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  sword::SWBuf *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__InstallSource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InstallSource_u_get" "', argument " "1"" of type '" "sword::InstallSource *""'"); 
  }
  arg1 = reinterpret_cast< sword::InstallSource * >(argp1);
  result = (sword::SWBuf *)& ((arg1)->u);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__SWBuf, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InstallSource_p_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::InstallSource *arg1 = 0 ;
  sword::SWBuf *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "InstallSource_p_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__InstallSource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InstallSource_p_set" "', argument " "1"" of type '" "sword::InstallSource *""'"); 
  }
  arg1 = reinterpret_cast< sword::InstallSource * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_sword__SWBuf, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InstallSource_p_set" "', argument " "2"" of type '" "sword::SWBuf *""'"); 
  }
  arg2 = reinterpret_cast< sword::SWBuf * >(argp2);
  if (arg1) (arg1)->p = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InstallSource_p_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::InstallSource *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  sword::SWBuf *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__InstallSource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InstallSource_p_get" "', argument " "1"" of type '" "sword::InstallSource *""'"); 
  }
  arg1 = reinterpret_cast< sword::InstallSource * >(argp1);
  result = (sword::SWBuf *)& ((arg1)->p);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__SWBuf, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InstallSource_uid_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::InstallSource *arg1 = 0 ;
  sword::SWBuf *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "InstallSource_uid_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__InstallSource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InstallSource_uid_set" "', argument " "1"" of type '" "sword::InstallSource *""'"); 
  }
  arg1 = reinterpret_cast< sword::InstallSource * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_sword__SWBuf, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InstallSource_uid_set" "', argument " "2"" of type '" "sword::SWBuf *""'"); 
  }
  arg2 = reinterpret_cast< sword::SWBuf * >(argp2);
  if (arg1) (arg1)->uid = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InstallSource_uid_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::InstallSource *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  sword::SWBuf *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__InstallSource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InstallSource_uid_get" "', argument " "1"" of type '" "sword::InstallSource *""'"); 
  }
  arg1 = reinterpret_cast< sword::InstallSource * >(argp1);
  result = (sword::SWBuf *)& ((arg1)->uid);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__SWBuf, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InstallSource_type_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::InstallSource *arg1 = 0 ;
  sword::SWBuf *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "InstallSource_type_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__InstallSource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InstallSource_type_set" "', argument " "1"" of type '" "sword::InstallSource *""'"); 
  }
  arg1 = reinterpret_cast< sword::InstallSource * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_sword__SWBuf, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InstallSource_type_set" "', argument " "2"" of type '" "sword::SWBuf *""'"); 
  }
  arg2 = reinterpret_cast< sword::SWBuf * >(argp2);
  if (arg1) (arg1)->type = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InstallSource_type_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::InstallSource *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  sword::SWBuf *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__InstallSource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InstallSource_type_get" "', argument " "1"" of type '" "sword::InstallSource *""'"); 
  }
  arg1 = reinterpret_cast< sword::InstallSource * >(argp1);
  result = (sword::SWBuf *)& ((arg1)->type);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__SWBuf, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InstallSource_localShadow_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::InstallSource *arg1 = 0 ;
  sword::SWBuf *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "InstallSource_localShadow_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__InstallSource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InstallSource_localShadow_set" "', argument " "1"" of type '" "sword::InstallSource *""'"); 
  }
  arg1 = reinterpret_cast< sword::InstallSource * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_sword__SWBuf, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InstallSource_localShadow_set" "', argument " "2"" of type '" "sword::SWBuf *""'"); 
  }
  arg2 = reinterpret_cast< sword::SWBuf * >(argp2);
  if (arg1) (arg1)->localShadow = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InstallSource_localShadow_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::InstallSource *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  sword::SWBuf *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__InstallSource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InstallSource_localShadow_get" "', argument " "1"" of type '" "sword::InstallSource *""'"); 
  }
  arg1 = reinterpret_cast< sword::InstallSource * >(argp1);
  result = (sword::SWBuf *)& ((arg1)->localShadow);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__SWBuf, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InstallSource_getMgr(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::InstallSource *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  sword::SWMgr *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__InstallSource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InstallSource_getMgr" "', argument " "1"" of type '" "sword::InstallSource *""'"); 
  }
  arg1 = reinterpret_cast< sword::InstallSource * >(argp1);
  {
    try {
      result = (sword::SWMgr *)(arg1)->getMgr(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__SWMgr, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InstallSource_flush(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::InstallSource *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__InstallSource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InstallSource_flush" "', argument " "1"" of type '" "sword::InstallSource *""'"); 
  }
  arg1 = reinterpret_cast< sword::InstallSource * >(argp1);
  {
    try {
      (arg1)->flush(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *InstallSource_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_sword__InstallSource, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *InstallSource_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN int Swig_var_InstallMgr_userDisclaimerConfirmed_set(PyObject *_val) {
  {
    bool val;
    int res = SWIG_AsVal_bool(_val, &val);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in variable '""sword::InstallMgr::userDisclaimerConfirmed""' of type '""bool""'");
    }
    sword::InstallMgr::userDisclaimerConfirmed = static_cast< bool >(val);
  }
  return 0;
fail:
  return 1;
}


SWIGINTERN PyObject *Swig_var_InstallMgr_userDisclaimerConfirmed_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_bool(static_cast< bool >(sword::InstallMgr::userDisclaimerConfirmed));
  return pyobj;
}


SWIGINTERN PyObject *_wrap_InstallMgr_userDisclaimerConfirmed_get(PyObject *SWIGUNUSEDPARM(self), PyObject *SWIGUNUSEDPARM(args)) {
  return Swig_var_InstallMgr_userDisclaimerConfirmed_get();
}


SWIGINTERN PyObject *_wrap_InstallMgr_userDisclaimerConfirmed_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  int res;
  
  res = Swig_var_InstallMgr_userDisclaimerConfirmed_set(args);
  return !res ? SWIG_Py_Void() : NULL;
}


SWIGINTERN int Swig_var_InstallMgr_MODSTAT_OLDER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable InstallMgr_MODSTAT_OLDER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_InstallMgr_MODSTAT_OLDER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(sword::InstallMgr::MODSTAT_OLDER));
  return pyobj;
}


SWIGINTERN int Swig_var_InstallMgr_MODSTAT_SAMEVERSION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable InstallMgr_MODSTAT_SAMEVERSION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_InstallMgr_MODSTAT_SAMEVERSION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(sword::InstallMgr::MODSTAT_SAMEVERSION));
  return pyobj;
}


SWIGINTERN int Swig_var_InstallMgr_MODSTAT_UPDATED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable InstallMgr_MODSTAT_UPDATED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_InstallMgr_MODSTAT_UPDATED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(sword::InstallMgr::MODSTAT_UPDATED));
  return pyobj;
}


SWIGINTERN int Swig_var_InstallMgr_MODSTAT_NEW_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable InstallMgr_MODSTAT_NEW is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_InstallMgr_MODSTAT_NEW_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(sword::InstallMgr::MODSTAT_NEW));
  return pyobj;
}


SWIGINTERN int Swig_var_InstallMgr_MODSTAT_CIPHERED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable InstallMgr_MODSTAT_CIPHERED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_InstallMgr_MODSTAT_CIPHERED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(sword::InstallMgr::MODSTAT_CIPHERED));
  return pyobj;
}


SWIGINTERN int Swig_var_InstallMgr_MODSTAT_CIPHERKEYPRESENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable InstallMgr_MODSTAT_CIPHERKEYPRESENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_InstallMgr_MODSTAT_CIPHERKEYPRESENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(sword::InstallMgr::MODSTAT_CIPHERKEYPRESENT));
  return pyobj;
}


SWIGINTERN PyObject *_wrap_InstallMgr_installConf_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::InstallMgr *arg1 = 0 ;
  sword::SWConfig *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "InstallMgr_installConf_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__InstallMgr, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InstallMgr_installConf_set" "', argument " "1"" of type '" "sword::InstallMgr *""'"); 
  }
  arg1 = reinterpret_cast< sword::InstallMgr * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_sword__SWConfig, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InstallMgr_installConf_set" "', argument " "2"" of type '" "sword::SWConfig *""'"); 
  }
  arg2 = reinterpret_cast< sword::SWConfig * >(argp2);
  if (arg1) (arg1)->installConf = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InstallMgr_installConf_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::InstallMgr *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  sword::SWConfig *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__InstallMgr, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InstallMgr_installConf_get" "', argument " "1"" of type '" "sword::InstallMgr *""'"); 
  }
  arg1 = reinterpret_cast< sword::InstallMgr * >(argp1);
  result = (sword::SWConfig *) ((arg1)->installConf);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__SWConfig, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InstallMgr_sources_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::InstallMgr *arg1 = 0 ;
  sword::InstallSourceMap *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "InstallMgr_sources_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__InstallMgr, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InstallMgr_sources_set" "', argument " "1"" of type '" "sword::InstallMgr *""'"); 
  }
  arg1 = reinterpret_cast< sword::InstallMgr * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_std__mapT_sword__SWBuf_sword__InstallSource_p_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InstallMgr_sources_set" "', argument " "2"" of type '" "sword::InstallSourceMap *""'"); 
  }
  arg2 = reinterpret_cast< sword::InstallSourceMap * >(argp2);
  if (arg1) (arg1)->sources = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InstallMgr_sources_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::InstallMgr *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  sword::InstallSourceMap *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__InstallMgr, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InstallMgr_sources_get" "', argument " "1"" of type '" "sword::InstallMgr *""'"); 
  }
  arg1 = reinterpret_cast< sword::InstallMgr * >(argp1);
  result = (sword::InstallSourceMap *)& ((arg1)->sources);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__mapT_sword__SWBuf_sword__InstallSource_p_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_InstallMgr__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  sword::StatusReporter *arg2 = 0 ;
  sword::SWBuf arg3 ;
  sword::SWBuf arg4 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  sword::InstallMgr *result = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_InstallMgr" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_sword__StatusReporter, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_InstallMgr" "', argument " "2"" of type '" "sword::StatusReporter *""'"); 
  }
  arg2 = reinterpret_cast< sword::StatusReporter * >(argp2);
  {
    res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_sword__SWBuf,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_InstallMgr" "', argument " "3"" of type '" "sword::SWBuf""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_InstallMgr" "', argument " "3"" of type '" "sword::SWBuf""'");
    } else {
      sword::SWBuf * temp = reinterpret_cast< sword::SWBuf * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  {
    res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_sword__SWBuf,  0  | 0);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_InstallMgr" "', argument " "4"" of type '" "sword::SWBuf""'"); 
    }  
    if (!argp4) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_InstallMgr" "', argument " "4"" of type '" "sword::SWBuf""'");
    } else {
      sword::SWBuf * temp = reinterpret_cast< sword::SWBuf * >(argp4);
      arg4 = *temp;
      if (SWIG_IsNewObj(res4)) delete temp;
    }
  }
  {
    try {
      result = (sword::InstallMgr *)new sword::InstallMgr((char const *)arg1,arg2,SWIG_STD_MOVE(arg3),SWIG_STD_MOVE(arg4)); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__InstallMgr, SWIG_POINTER_NEW |  0 );
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_InstallMgr__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  sword::StatusReporter *arg2 = 0 ;
  sword::SWBuf arg3 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  sword::InstallMgr *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_InstallMgr" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_sword__StatusReporter, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_InstallMgr" "', argument " "2"" of type '" "sword::StatusReporter *""'"); 
  }
  arg2 = reinterpret_cast< sword::StatusReporter * >(argp2);
  {
    res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_sword__SWBuf,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_InstallMgr" "', argument " "3"" of type '" "sword::SWBuf""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_InstallMgr" "', argument " "3"" of type '" "sword::SWBuf""'");
    } else {
      sword::SWBuf * temp = reinterpret_cast< sword::SWBuf * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  {
    try {
      result = (sword::InstallMgr *)new sword::InstallMgr((char const *)arg1,arg2,SWIG_STD_MOVE(arg3)); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__InstallMgr, SWIG_POINTER_NEW |  0 );
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_InstallMgr__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  sword::StatusReporter *arg2 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  sword::InstallMgr *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_InstallMgr" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_sword__StatusReporter, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_InstallMgr" "', argument " "2"" of type '" "sword::StatusReporter *""'"); 
  }
  arg2 = reinterpret_cast< sword::StatusReporter * >(argp2);
  {
    try {
      result = (sword::InstallMgr *)new sword::InstallMgr((char const *)arg1,arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__InstallMgr, SWIG_POINTER_NEW |  0 );
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_InstallMgr__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  sword::InstallMgr *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_InstallMgr" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  {
    try {
      result = (sword::InstallMgr *)new sword::InstallMgr((char const *)arg1); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__InstallMgr, SWIG_POINTER_NEW |  0 );
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_InstallMgr__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  sword::InstallMgr *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (sword::InstallMgr *)new sword::InstallMgr(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sword__InstallMgr, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_InstallMgr(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_InstallMgr", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_InstallMgr__SWIG_4(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_InstallMgr__SWIG_3(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_sword__StatusReporter, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_InstallMgr__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_sword__StatusReporter, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_sword__SWBuf, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_new_InstallMgr__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_sword__StatusReporter, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_sword__SWBuf, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_sword__SWBuf, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_new_InstallMgr__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_InstallMgr'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    sword::InstallMgr::InstallMgr(char const *,sword::StatusReporter *,sword::SWBuf,sword::SWBuf)\n"
    "    sword::InstallMgr::InstallMgr(char const *,sword::StatusReporter *,sword::SWBuf)\n"
    "    sword::InstallMgr::InstallMgr(char const *,sword::StatusReporter *)\n"
    "    sword::InstallMgr::InstallMgr(char const *)\n"
    "    sword::InstallMgr::InstallMgr()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_InstallMgr(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::InstallMgr *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__InstallMgr, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_InstallMgr" "', argument " "1"" of type '" "sword::InstallMgr *""'"); 
  }
  arg1 = reinterpret_cast< sword::InstallMgr * >(argp1);
  {
    try {
      delete arg1; 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InstallMgr_readInstallConf(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::InstallMgr *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__InstallMgr, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InstallMgr_readInstallConf" "', argument " "1"" of type '" "sword::InstallMgr *""'"); 
  }
  arg1 = reinterpret_cast< sword::InstallMgr * >(argp1);
  {
    try {
      (arg1)->readInstallConf(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InstallMgr_saveInstallConf(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::InstallMgr *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__InstallMgr, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InstallMgr_saveInstallConf" "', argument " "1"" of type '" "sword::InstallMgr *""'"); 
  }
  arg1 = reinterpret_cast< sword::InstallMgr * >(argp1);
  {
    try {
      (arg1)->saveInstallConf(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InstallMgr_clearSources(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::InstallMgr *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__InstallMgr, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InstallMgr_clearSources" "', argument " "1"" of type '" "sword::InstallMgr *""'"); 
  }
  arg1 = reinterpret_cast< sword::InstallMgr * >(argp1);
  {
    try {
      (arg1)->clearSources(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InstallMgr_removeModule(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::InstallMgr *arg1 = 0 ;
  sword::SWMgr *arg2 = 0 ;
  char *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  PyObject *swig_obj[3] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "InstallMgr_removeModule", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__InstallMgr, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InstallMgr_removeModule" "', argument " "1"" of type '" "sword::InstallMgr *""'"); 
  }
  arg1 = reinterpret_cast< sword::InstallMgr * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_sword__SWMgr, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InstallMgr_removeModule" "', argument " "2"" of type '" "sword::SWMgr *""'"); 
  }
  arg2 = reinterpret_cast< sword::SWMgr * >(argp2);
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "InstallMgr_removeModule" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  {
    try {
      result = (int)(arg1)->removeModule(arg2,(char const *)arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return resultobj;
fail:
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_InstallMgr_remoteCopy__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::InstallMgr *arg1 = 0 ;
  sword::InstallSource *arg2 = 0 ;
  char *arg3 = 0 ;
  char *arg4 = 0 ;
  bool arg5 ;
  char *arg6 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  int res4 ;
  char *buf4 = 0 ;
  int alloc4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  int res6 ;
  char *buf6 = 0 ;
  int alloc6 = 0 ;
  int result;
  
  (void)self;
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__InstallMgr, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InstallMgr_remoteCopy" "', argument " "1"" of type '" "sword::InstallMgr *""'"); 
  }
  arg1 = reinterpret_cast< sword::InstallMgr * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_sword__InstallSource, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InstallMgr_remoteCopy" "', argument " "2"" of type '" "sword::InstallSource *""'"); 
  }
  arg2 = reinterpret_cast< sword::InstallSource * >(argp2);
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "InstallMgr_remoteCopy" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  res4 = SWIG_AsCharPtrAndSize(swig_obj[3], &buf4, NULL, &alloc4);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "InstallMgr_remoteCopy" "', argument " "4"" of type '" "char const *""'");
  }
  arg4 = reinterpret_cast< char * >(buf4);
  ecode5 = SWIG_AsVal_bool(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "InstallMgr_remoteCopy" "', argument " "5"" of type '" "bool""'");
  } 
  arg5 = static_cast< bool >(val5);
  res6 = SWIG_AsCharPtrAndSize(swig_obj[5], &buf6, NULL, &alloc6);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "InstallMgr_remoteCopy" "', argument " "6"" of type '" "char const *""'");
  }
  arg6 = reinterpret_cast< char * >(buf6);
  {
    try {
      result = (int)(arg1)->remoteCopy(arg2,(char const *)arg3,(char const *)arg4,arg5,(char const *)arg6); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
  if (alloc6 == SWIG_NEWOBJ) delete[] buf6;
  return resultobj;
fail:
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
  if (alloc6 == SWIG_NEWOBJ) delete[] buf6;
  return NULL;
}


SWIGINTERN PyObject *_wrap_InstallMgr_remoteCopy__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::InstallMgr *arg1 = 0 ;
  sword::InstallSource *arg2 = 0 ;
  char *arg3 = 0 ;
  char *arg4 = 0 ;
  bool arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  int res4 ;
  char *buf4 = 0 ;
  int alloc4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  int result;
  
  (void)self;
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__InstallMgr, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InstallMgr_remoteCopy" "', argument " "1"" of type '" "sword::InstallMgr *""'"); 
  }
  arg1 = reinterpret_cast< sword::InstallMgr * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_sword__InstallSource, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InstallMgr_remoteCopy" "', argument " "2"" of type '" "sword::InstallSource *""'"); 
  }
  arg2 = reinterpret_cast< sword::InstallSource * >(argp2);
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "InstallMgr_remoteCopy" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  res4 = SWIG_AsCharPtrAndSize(swig_obj[3], &buf4, NULL, &alloc4);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "InstallMgr_remoteCopy" "', argument " "4"" of type '" "char const *""'");
  }
  arg4 = reinterpret_cast< char * >(buf4);
  ecode5 = SWIG_AsVal_bool(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "InstallMgr_remoteCopy" "', argument " "5"" of type '" "bool""'");
  } 
  arg5 = static_cast< bool >(val5);
  {
    try {
      result = (int)(arg1)->remoteCopy(arg2,(char const *)arg3,(char const *)arg4,arg5); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
  return resultobj;
fail:
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_InstallMgr_remoteCopy__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::InstallMgr *arg1 = 0 ;
  sword::InstallSource *arg2 = 0 ;
  char *arg3 = 0 ;
  char *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  int res4 ;
  char *buf4 = 0 ;
  int alloc4 = 0 ;
  int result;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__InstallMgr, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InstallMgr_remoteCopy" "', argument " "1"" of type '" "sword::InstallMgr *""'"); 
  }
  arg1 = reinterpret_cast< sword::InstallMgr * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_sword__InstallSource, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InstallMgr_remoteCopy" "', argument " "2"" of type '" "sword::InstallSource *""'"); 
  }
  arg2 = reinterpret_cast< sword::InstallSource * >(argp2);
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "InstallMgr_remoteCopy" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  res4 = SWIG_AsCharPtrAndSize(swig_obj[3], &buf4, NULL, &alloc4);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "InstallMgr_remoteCopy" "', argument " "4"" of type '" "char const *""'");
  }
  arg4 = reinterpret_cast< char * >(buf4);
  {
    try {
      result = (int)(arg1)->remoteCopy(arg2,(char const *)arg3,(char const *)arg4); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
  return resultobj;
fail:
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_InstallMgr_remoteCopy(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[7] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "InstallMgr_remoteCopy", 0, 6, argv))) SWIG_fail;
  --argc;
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__InstallMgr, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_sword__InstallSource, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_AsCharPtrAndSize(argv[3], 0, NULL, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_InstallMgr_remoteCopy__SWIG_2(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__InstallMgr, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_sword__InstallSource, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_AsCharPtrAndSize(argv[3], 0, NULL, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_bool(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_InstallMgr_remoteCopy__SWIG_1(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__InstallMgr, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_sword__InstallSource, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_AsCharPtrAndSize(argv[3], 0, NULL, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_bool(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_AsCharPtrAndSize(argv[5], 0, NULL, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                return _wrap_InstallMgr_remoteCopy__SWIG_0(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'InstallMgr_remoteCopy'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    sword::InstallMgr::remoteCopy(sword::InstallSource *,char const *,char const *,bool,char const *)\n"
    "    sword::InstallMgr::remoteCopy(sword::InstallSource *,char const *,char const *,bool)\n"
    "    sword::InstallMgr::remoteCopy(sword::InstallSource *,char const *,char const *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_InstallMgr_installModule__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::InstallMgr *arg1 = 0 ;
  sword::SWMgr *arg2 = 0 ;
  char *arg3 = 0 ;
  char *arg4 = 0 ;
  sword::InstallSource *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  int res4 ;
  char *buf4 = 0 ;
  int alloc4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  int result;
  
  (void)self;
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__InstallMgr, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InstallMgr_installModule" "', argument " "1"" of type '" "sword::InstallMgr *""'"); 
  }
  arg1 = reinterpret_cast< sword::InstallMgr * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_sword__SWMgr, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InstallMgr_installModule" "', argument " "2"" of type '" "sword::SWMgr *""'"); 
  }
  arg2 = reinterpret_cast< sword::SWMgr * >(argp2);
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "InstallMgr_installModule" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  res4 = SWIG_AsCharPtrAndSize(swig_obj[3], &buf4, NULL, &alloc4);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "InstallMgr_installModule" "', argument " "4"" of type '" "char const *""'");
  }
  arg4 = reinterpret_cast< char * >(buf4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5,SWIGTYPE_p_sword__InstallSource, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "InstallMgr_installModule" "', argument " "5"" of type '" "sword::InstallSource *""'"); 
  }
  arg5 = reinterpret_cast< sword::InstallSource * >(argp5);
  {
    try {
      result = (int)(arg1)->installModule(arg2,(char const *)arg3,(char const *)arg4,arg5); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
  return resultobj;
fail:
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_InstallMgr_installModule__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::InstallMgr *arg1 = 0 ;
  sword::SWMgr *arg2 = 0 ;
  char *arg3 = 0 ;
  char *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  int res4 ;
  char *buf4 = 0 ;
  int alloc4 = 0 ;
  int result;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__InstallMgr, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InstallMgr_installModule" "', argument " "1"" of type '" "sword::InstallMgr *""'"); 
  }
  arg1 = reinterpret_cast< sword::InstallMgr * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_sword__SWMgr, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InstallMgr_installModule" "', argument " "2"" of type '" "sword::SWMgr *""'"); 
  }
  arg2 = reinterpret_cast< sword::SWMgr * >(argp2);
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "InstallMgr_installModule" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  res4 = SWIG_AsCharPtrAndSize(swig_obj[3], &buf4, NULL, &alloc4);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "InstallMgr_installModule" "', argument " "4"" of type '" "char const *""'");
  }
  arg4 = reinterpret_cast< char * >(buf4);
  {
    try {
      result = (int)(arg1)->installModule(arg2,(char const *)arg3,(char const *)arg4); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
  return resultobj;
fail:
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_InstallMgr_installModule(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "InstallMgr_installModule", 0, 5, argv))) SWIG_fail;
  --argc;
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__InstallMgr, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_sword__SWMgr, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_AsCharPtrAndSize(argv[3], 0, NULL, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_InstallMgr_installModule__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_sword__InstallMgr, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_sword__SWMgr, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_AsCharPtrAndSize(argv[3], 0, NULL, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_sword__InstallSource, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_InstallMgr_installModule__SWIG_0(self, argc, argv);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'InstallMgr_installModule'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    sword::InstallMgr::installModule(sword::SWMgr *,char const *,char const *,sword::InstallSource *)\n"
    "    sword::InstallMgr::installModule(sword::SWMgr *,char const *,char const *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_InstallMgr_refreshRemoteSource(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::InstallMgr *arg1 = 0 ;
  sword::InstallSource *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "InstallMgr_refreshRemoteSource", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__InstallMgr, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InstallMgr_refreshRemoteSource" "', argument " "1"" of type '" "sword::InstallMgr *""'"); 
  }
  arg1 = reinterpret_cast< sword::InstallMgr * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_sword__InstallSource, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InstallMgr_refreshRemoteSource" "', argument " "2"" of type '" "sword::InstallSource *""'"); 
  }
  arg2 = reinterpret_cast< sword::InstallSource * >(argp2);
  {
    try {
      result = (int)(arg1)->refreshRemoteSource(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InstallMgr_refreshRemoteSourceConfiguration(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::InstallMgr *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__InstallMgr, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InstallMgr_refreshRemoteSourceConfiguration" "', argument " "1"" of type '" "sword::InstallMgr *""'"); 
  }
  arg1 = reinterpret_cast< sword::InstallMgr * >(argp1);
  {
    try {
      result = (int)(arg1)->refreshRemoteSourceConfiguration(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InstallMgr_isUserDisclaimerConfirmed(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::InstallMgr *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__InstallMgr, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InstallMgr_isUserDisclaimerConfirmed" "', argument " "1"" of type '" "sword::InstallMgr const *""'"); 
  }
  arg1 = reinterpret_cast< sword::InstallMgr * >(argp1);
  {
    try {
      result = (bool)((sword::InstallMgr const *)arg1)->isUserDisclaimerConfirmed(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InstallMgr_setUserDisclaimerConfirmed(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::InstallMgr *arg1 = 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "InstallMgr_setUserDisclaimerConfirmed", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__InstallMgr, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InstallMgr_setUserDisclaimerConfirmed" "', argument " "1"" of type '" "sword::InstallMgr *""'"); 
  }
  arg1 = reinterpret_cast< sword::InstallMgr * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InstallMgr_setUserDisclaimerConfirmed" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    try {
      (arg1)->setUserDisclaimerConfirmed(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InstallMgr_getCipherCode(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::InstallMgr *arg1 = 0 ;
  char *arg2 = 0 ;
  sword::SWConfig *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "InstallMgr_getCipherCode", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__InstallMgr, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InstallMgr_getCipherCode" "', argument " "1"" of type '" "sword::InstallMgr *""'"); 
  }
  arg1 = reinterpret_cast< sword::InstallMgr * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InstallMgr_getCipherCode" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_sword__SWConfig, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "InstallMgr_getCipherCode" "', argument " "3"" of type '" "sword::SWConfig *""'"); 
  }
  arg3 = reinterpret_cast< sword::SWConfig * >(argp3);
  {
    try {
      result = (bool)(arg1)->getCipherCode((char const *)arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_InstallMgr_setFTPPassive(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::InstallMgr *arg1 = 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "InstallMgr_setFTPPassive", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__InstallMgr, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InstallMgr_setFTPPassive" "', argument " "1"" of type '" "sword::InstallMgr *""'"); 
  }
  arg1 = reinterpret_cast< sword::InstallMgr * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InstallMgr_setFTPPassive" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    try {
      (arg1)->setFTPPassive(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InstallMgr_isFTPPassive(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::InstallMgr *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__InstallMgr, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InstallMgr_isFTPPassive" "', argument " "1"" of type '" "sword::InstallMgr *""'"); 
  }
  arg1 = reinterpret_cast< sword::InstallMgr * >(argp1);
  {
    try {
      result = (bool)(arg1)->isFTPPassive(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InstallMgr_setTimeoutMillis(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::InstallMgr *arg1 = 0 ;
  long arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  long val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "InstallMgr_setTimeoutMillis", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__InstallMgr, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InstallMgr_setTimeoutMillis" "', argument " "1"" of type '" "sword::InstallMgr *""'"); 
  }
  arg1 = reinterpret_cast< sword::InstallMgr * >(argp1);
  ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InstallMgr_setTimeoutMillis" "', argument " "2"" of type '" "long""'");
  } 
  arg2 = static_cast< long >(val2);
  {
    try {
      (arg1)->setTimeoutMillis(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InstallMgr_getTimeoutMillis(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::InstallMgr *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  long result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__InstallMgr, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InstallMgr_getTimeoutMillis" "', argument " "1"" of type '" "sword::InstallMgr *""'"); 
  }
  arg1 = reinterpret_cast< sword::InstallMgr * >(argp1);
  {
    try {
      result = (long)(arg1)->getTimeoutMillis(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_long(static_cast< long >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InstallMgr_setUnverifiedPeerAllowed(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::InstallMgr *arg1 = 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "InstallMgr_setUnverifiedPeerAllowed", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__InstallMgr, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InstallMgr_setUnverifiedPeerAllowed" "', argument " "1"" of type '" "sword::InstallMgr *""'"); 
  }
  arg1 = reinterpret_cast< sword::InstallMgr * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InstallMgr_setUnverifiedPeerAllowed" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    try {
      (arg1)->setUnverifiedPeerAllowed(arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InstallMgr_isUnverifiedPeerAllowed(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::InstallMgr *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__InstallMgr, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InstallMgr_isUnverifiedPeerAllowed" "', argument " "1"" of type '" "sword::InstallMgr *""'"); 
  }
  arg1 = reinterpret_cast< sword::InstallMgr * >(argp1);
  {
    try {
      result = (bool)(arg1)->isUnverifiedPeerAllowed(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InstallMgr_terminate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::InstallMgr *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__InstallMgr, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InstallMgr_terminate" "', argument " "1"" of type '" "sword::InstallMgr *""'"); 
  }
  arg1 = reinterpret_cast< sword::InstallMgr * >(argp1);
  {
    try {
      (arg1)->terminate(); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InstallMgr_getModuleStatus__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::SWMgr *arg1 = 0 ;
  sword::SWMgr *arg2 = 0 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  std::map< sword::SWModule *,int,std::less< sword::SWModule * >,std::allocator< std::pair< sword::SWModule *const,int > > > result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_sword__SWMgr,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InstallMgr_getModuleStatus" "', argument " "1"" of type '" "sword::SWMgr const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "InstallMgr_getModuleStatus" "', argument " "1"" of type '" "sword::SWMgr const &""'"); 
  }
  arg1 = reinterpret_cast< sword::SWMgr * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_sword__SWMgr,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InstallMgr_getModuleStatus" "', argument " "2"" of type '" "sword::SWMgr const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "InstallMgr_getModuleStatus" "', argument " "2"" of type '" "sword::SWMgr const &""'"); 
  }
  arg2 = reinterpret_cast< sword::SWMgr * >(argp2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "InstallMgr_getModuleStatus" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    try {
      result = sword::InstallMgr::getModuleStatus((sword::SWMgr const &)*arg1,(sword::SWMgr const &)*arg2,arg3); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = swig::from(static_cast< std::map< sword::SWModule *,int,std::less< sword::SWModule * >,std::allocator< std::pair< sword::SWModule *const,int > > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InstallMgr_getModuleStatus__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  sword::SWMgr *arg1 = 0 ;
  sword::SWMgr *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  std::map< sword::SWModule *,int,std::less< sword::SWModule * >,std::allocator< std::pair< sword::SWModule *const,int > > > result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_sword__SWMgr,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InstallMgr_getModuleStatus" "', argument " "1"" of type '" "sword::SWMgr const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "InstallMgr_getModuleStatus" "', argument " "1"" of type '" "sword::SWMgr const &""'"); 
  }
  arg1 = reinterpret_cast< sword::SWMgr * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_sword__SWMgr,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InstallMgr_getModuleStatus" "', argument " "2"" of type '" "sword::SWMgr const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "InstallMgr_getModuleStatus" "', argument " "2"" of type '" "sword::SWMgr const &""'"); 
  }
  arg2 = reinterpret_cast< sword::SWMgr * >(argp2);
  {
    try {
      result = sword::InstallMgr::getModuleStatus((sword::SWMgr const &)*arg1,(sword::SWMgr const &)*arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = swig::from(static_cast< std::map< sword::SWModule *,int,std::less< sword::SWModule * >,std::allocator< std::pair< sword::SWModule *const,int > > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InstallMgr_getModuleStatus(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "InstallMgr_getModuleStatus", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_sword__SWMgr, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_sword__SWMgr, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_InstallMgr_getModuleStatus__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_sword__SWMgr, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_sword__SWMgr, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_InstallMgr_getModuleStatus__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'InstallMgr_getModuleStatus'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    sword::InstallMgr::getModuleStatus(sword::SWMgr const &,sword::SWMgr const &,bool)\n"
    "    sword::InstallMgr::getModuleStatus(sword::SWMgr const &,sword::SWMgr const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_InstallMgr_isDefaultModule(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  sword::InstallMgr *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "InstallMgr_isDefaultModule", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_sword__InstallMgr, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InstallMgr_isDefaultModule" "', argument " "1"" of type '" "sword::InstallMgr *""'"); 
  }
  arg1 = reinterpret_cast< sword::InstallMgr * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InstallMgr_isDefaultModule" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    try {
      result = (bool)(arg1)->isDefaultModule((char const *)arg2); 
    }
    catch (Swig::DirectorException &e) {
      SWIG_fail; 
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *InstallMgr_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_sword__InstallMgr, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *InstallMgr_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

static PyMethodDef SwigMethods[] = {
	 { "SWBuf_nullStr_get", _wrap_SWBuf_nullStr_get, METH_VARARGS, NULL},
	 { "SWBuf_nullStr_set", _wrap_SWBuf_nullStr_set, METH_O, NULL},
	 { "new_SWBuf", _wrap_new_SWBuf, METH_VARARGS, NULL},
	 { "delete_SWBuf", _wrap_delete_SWBuf, METH_O, NULL},
	 { "SWBuf_setFillByte", _wrap_SWBuf_setFillByte, METH_VARARGS, NULL},
	 { "SWBuf_getFillByte", _wrap_SWBuf_getFillByte, METH_O, NULL},
	 { "SWBuf_c_str", _wrap_SWBuf_c_str, METH_O, NULL},
	 { "SWBuf_charAtGuarded", _wrap_SWBuf_charAtGuarded, METH_VARARGS, NULL},
	 { "SWBuf_charAt", _wrap_SWBuf_charAt, METH_VARARGS, NULL},
	 { "SWBuf_size", _wrap_SWBuf_size, METH_VARARGS, NULL},
	 { "SWBuf_length", _wrap_SWBuf_length, METH_O, NULL},
	 { "SWBuf_set", _wrap_SWBuf_set, METH_VARARGS, NULL},
	 { "SWBuf_setFormatted", _wrap_SWBuf_setFormatted, METH_VARARGS, NULL},
	 { "SWBuf_setSize", _wrap_SWBuf_setSize, METH_VARARGS, NULL},
	 { "SWBuf_resize", _wrap_SWBuf_resize, METH_VARARGS, NULL},
	 { "SWBuf_append", _wrap_SWBuf_append, METH_VARARGS, NULL},
	 { "SWBuf_appendFormatted", _wrap_SWBuf_appendFormatted, METH_VARARGS, NULL},
	 { "SWBuf_insert", _wrap_SWBuf_insert, METH_VARARGS, NULL},
	 { "SWBuf_getRawData", _wrap_SWBuf_getRawData, METH_O, NULL},
	 { "SWBuf___str__", _wrap_SWBuf___str__, METH_O, NULL},
	 { "SWBuf_trimStart", _wrap_SWBuf_trimStart, METH_O, NULL},
	 { "SWBuf_trimEnd", _wrap_SWBuf_trimEnd, METH_O, NULL},
	 { "SWBuf_trim", _wrap_SWBuf_trim, METH_O, NULL},
	 { "SWBuf_stripPrefix", _wrap_SWBuf_stripPrefix, METH_VARARGS, NULL},
	 { "SWBuf_replaceBytes", _wrap_SWBuf_replaceBytes, METH_VARARGS, NULL},
	 { "SWBuf_toUpper", _wrap_SWBuf_toUpper, METH_O, NULL},
	 { "SWBuf_toLower", _wrap_SWBuf_toLower, METH_O, NULL},
	 { "SWBuf_indexOf", _wrap_SWBuf_indexOf, METH_VARARGS, NULL},
	 { "SWBuf_startsWith", _wrap_SWBuf_startsWith, METH_VARARGS, NULL},
	 { "SWBuf_endsWith", _wrap_SWBuf_endsWith, METH_VARARGS, NULL},
	 { "SWBuf_compare", _wrap_SWBuf_compare, METH_VARARGS, NULL},
	 { "SWBuf_charAt2", _wrap_SWBuf_charAt2, METH_VARARGS, NULL},
	 { "SWBuf_swigregister", SWBuf_swigregister, METH_O, NULL},
	 { "SWBuf_swiginit", SWBuf_swiginit, METH_VARARGS, NULL},
	 { "delete_SwigPyIterator", _wrap_delete_SwigPyIterator, METH_O, NULL},
	 { "SwigPyIterator_value", _wrap_SwigPyIterator_value, METH_O, NULL},
	 { "SwigPyIterator_incr", _wrap_SwigPyIterator_incr, METH_VARARGS, NULL},
	 { "SwigPyIterator_decr", _wrap_SwigPyIterator_decr, METH_VARARGS, NULL},
	 { "SwigPyIterator_distance", _wrap_SwigPyIterator_distance, METH_VARARGS, NULL},
	 { "SwigPyIterator_equal", _wrap_SwigPyIterator_equal, METH_VARARGS, NULL},
	 { "SwigPyIterator_copy", _wrap_SwigPyIterator_copy, METH_O, NULL},
	 { "SwigPyIterator_next", _wrap_SwigPyIterator_next, METH_O, NULL},
	 { "SwigPyIterator___next__", _wrap_SwigPyIterator___next__, METH_O, NULL},
	 { "SwigPyIterator_previous", _wrap_SwigPyIterator_previous, METH_O, NULL},
	 { "SwigPyIterator_advance", _wrap_SwigPyIterator_advance, METH_VARARGS, NULL},
	 { "SwigPyIterator___eq__", _wrap_SwigPyIterator___eq__, METH_VARARGS, NULL},
	 { "SwigPyIterator___ne__", _wrap_SwigPyIterator___ne__, METH_VARARGS, NULL},
	 { "SwigPyIterator___iadd__", _wrap_SwigPyIterator___iadd__, METH_VARARGS, NULL},
	 { "SwigPyIterator___isub__", _wrap_SwigPyIterator___isub__, METH_VARARGS, NULL},
	 { "SwigPyIterator___add__", _wrap_SwigPyIterator___add__, METH_VARARGS, NULL},
	 { "SwigPyIterator___sub__", _wrap_SwigPyIterator___sub__, METH_VARARGS, NULL},
	 { "SwigPyIterator_swigregister", SwigPyIterator_swigregister, METH_O, NULL},
	 { "AttributeValueMap_iterator", _wrap_AttributeValueMap_iterator, METH_O, NULL},
	 { "AttributeValueMap___nonzero__", _wrap_AttributeValueMap___nonzero__, METH_O, NULL},
	 { "AttributeValueMap___bool__", _wrap_AttributeValueMap___bool__, METH_O, NULL},
	 { "AttributeValueMap___len__", _wrap_AttributeValueMap___len__, METH_O, NULL},
	 { "AttributeValueMap___getitem__", _wrap_AttributeValueMap___getitem__, METH_VARARGS, NULL},
	 { "AttributeValueMap___delitem__", _wrap_AttributeValueMap___delitem__, METH_VARARGS, NULL},
	 { "AttributeValueMap_has_key", _wrap_AttributeValueMap_has_key, METH_VARARGS, NULL},
	 { "AttributeValueMap_keys", _wrap_AttributeValueMap_keys, METH_O, NULL},
	 { "AttributeValueMap_values", _wrap_AttributeValueMap_values, METH_O, NULL},
	 { "AttributeValueMap_items", _wrap_AttributeValueMap_items, METH_O, NULL},
	 { "AttributeValueMap___contains__", _wrap_AttributeValueMap___contains__, METH_VARARGS, NULL},
	 { "AttributeValueMap_key_iterator", _wrap_AttributeValueMap_key_iterator, METH_O, NULL},
	 { "AttributeValueMap_value_iterator", _wrap_AttributeValueMap_value_iterator, METH_O, NULL},
	 { "AttributeValueMap___setitem__", _wrap_AttributeValueMap___setitem__, METH_VARARGS, NULL},
	 { "AttributeValueMap_asdict", _wrap_AttributeValueMap_asdict, METH_O, NULL},
	 { "new_AttributeValueMap", _wrap_new_AttributeValueMap, METH_VARARGS, NULL},
	 { "AttributeValueMap_empty", _wrap_AttributeValueMap_empty, METH_O, NULL},
	 { "AttributeValueMap_size", _wrap_AttributeValueMap_size, METH_O, NULL},
	 { "AttributeValueMap_swap", _wrap_AttributeValueMap_swap, METH_VARARGS, NULL},
	 { "AttributeValueMap_begin", _wrap_AttributeValueMap_begin, METH_O, NULL},
	 { "AttributeValueMap_end", _wrap_AttributeValueMap_end, METH_O, NULL},
	 { "AttributeValueMap_rbegin", _wrap_AttributeValueMap_rbegin, METH_O, NULL},
	 { "AttributeValueMap_rend", _wrap_AttributeValueMap_rend, METH_O, NULL},
	 { "AttributeValueMap_clear", _wrap_AttributeValueMap_clear, METH_O, NULL},
	 { "AttributeValueMap_get_allocator", _wrap_AttributeValueMap_get_allocator, METH_O, NULL},
	 { "AttributeValueMap_count", _wrap_AttributeValueMap_count, METH_VARARGS, NULL},
	 { "AttributeValueMap_erase", _wrap_AttributeValueMap_erase, METH_VARARGS, NULL},
	 { "AttributeValueMap_find", _wrap_AttributeValueMap_find, METH_VARARGS, NULL},
	 { "AttributeValueMap_lower_bound", _wrap_AttributeValueMap_lower_bound, METH_VARARGS, NULL},
	 { "AttributeValueMap_upper_bound", _wrap_AttributeValueMap_upper_bound, METH_VARARGS, NULL},
	 { "delete_AttributeValueMap", _wrap_delete_AttributeValueMap, METH_O, NULL},
	 { "AttributeValueMap_swigregister", AttributeValueMap_swigregister, METH_O, NULL},
	 { "AttributeValueMap_swiginit", AttributeValueMap_swiginit, METH_VARARGS, NULL},
	 { "AttributeListMap_iterator", _wrap_AttributeListMap_iterator, METH_O, NULL},
	 { "AttributeListMap___nonzero__", _wrap_AttributeListMap___nonzero__, METH_O, NULL},
	 { "AttributeListMap___bool__", _wrap_AttributeListMap___bool__, METH_O, NULL},
	 { "AttributeListMap___len__", _wrap_AttributeListMap___len__, METH_O, NULL},
	 { "AttributeListMap___getitem__", _wrap_AttributeListMap___getitem__, METH_VARARGS, NULL},
	 { "AttributeListMap___delitem__", _wrap_AttributeListMap___delitem__, METH_VARARGS, NULL},
	 { "AttributeListMap_has_key", _wrap_AttributeListMap_has_key, METH_VARARGS, NULL},
	 { "AttributeListMap_keys", _wrap_AttributeListMap_keys, METH_O, NULL},
	 { "AttributeListMap_values", _wrap_AttributeListMap_values, METH_O, NULL},
	 { "AttributeListMap_items", _wrap_AttributeListMap_items, METH_O, NULL},
	 { "AttributeListMap___contains__", _wrap_AttributeListMap___contains__, METH_VARARGS, NULL},
	 { "AttributeListMap_key_iterator", _wrap_AttributeListMap_key_iterator, METH_O, NULL},
	 { "AttributeListMap_value_iterator", _wrap_AttributeListMap_value_iterator, METH_O, NULL},
	 { "AttributeListMap___setitem__", _wrap_AttributeListMap___setitem__, METH_VARARGS, NULL},
	 { "AttributeListMap_asdict", _wrap_AttributeListMap_asdict, METH_O, NULL},
	 { "new_AttributeListMap", _wrap_new_AttributeListMap, METH_VARARGS, NULL},
	 { "AttributeListMap_empty", _wrap_AttributeListMap_empty, METH_O, NULL},
	 { "AttributeListMap_size", _wrap_AttributeListMap_size, METH_O, NULL},
	 { "AttributeListMap_swap", _wrap_AttributeListMap_swap, METH_VARARGS, NULL},
	 { "AttributeListMap_begin", _wrap_AttributeListMap_begin, METH_O, NULL},
	 { "AttributeListMap_end", _wrap_AttributeListMap_end, METH_O, NULL},
	 { "AttributeListMap_rbegin", _wrap_AttributeListMap_rbegin, METH_O, NULL},
	 { "AttributeListMap_rend", _wrap_AttributeListMap_rend, METH_O, NULL},
	 { "AttributeListMap_clear", _wrap_AttributeListMap_clear, METH_O, NULL},
	 { "AttributeListMap_get_allocator", _wrap_AttributeListMap_get_allocator, METH_O, NULL},
	 { "AttributeListMap_count", _wrap_AttributeListMap_count, METH_VARARGS, NULL},
	 { "AttributeListMap_erase", _wrap_AttributeListMap_erase, METH_VARARGS, NULL},
	 { "AttributeListMap_find", _wrap_AttributeListMap_find, METH_VARARGS, NULL},
	 { "AttributeListMap_lower_bound", _wrap_AttributeListMap_lower_bound, METH_VARARGS, NULL},
	 { "AttributeListMap_upper_bound", _wrap_AttributeListMap_upper_bound, METH_VARARGS, NULL},
	 { "delete_AttributeListMap", _wrap_delete_AttributeListMap, METH_O, NULL},
	 { "AttributeListMap_swigregister", AttributeListMap_swigregister, METH_O, NULL},
	 { "AttributeListMap_swiginit", AttributeListMap_swiginit, METH_VARARGS, NULL},
	 { "AttributeTypeListMap_iterator", _wrap_AttributeTypeListMap_iterator, METH_O, NULL},
	 { "AttributeTypeListMap___nonzero__", _wrap_AttributeTypeListMap___nonzero__, METH_O, NULL},
	 { "AttributeTypeListMap___bool__", _wrap_AttributeTypeListMap___bool__, METH_O, NULL},
	 { "AttributeTypeListMap___len__", _wrap_AttributeTypeListMap___len__, METH_O, NULL},
	 { "AttributeTypeListMap___getitem__", _wrap_AttributeTypeListMap___getitem__, METH_VARARGS, NULL},
	 { "AttributeTypeListMap___delitem__", _wrap_AttributeTypeListMap___delitem__, METH_VARARGS, NULL},
	 { "AttributeTypeListMap_has_key", _wrap_AttributeTypeListMap_has_key, METH_VARARGS, NULL},
	 { "AttributeTypeListMap_keys", _wrap_AttributeTypeListMap_keys, METH_O, NULL},
	 { "AttributeTypeListMap_values", _wrap_AttributeTypeListMap_values, METH_O, NULL},
	 { "AttributeTypeListMap_items", _wrap_AttributeTypeListMap_items, METH_O, NULL},
	 { "AttributeTypeListMap___contains__", _wrap_AttributeTypeListMap___contains__, METH_VARARGS, NULL},
	 { "AttributeTypeListMap_key_iterator", _wrap_AttributeTypeListMap_key_iterator, METH_O, NULL},
	 { "AttributeTypeListMap_value_iterator", _wrap_AttributeTypeListMap_value_iterator, METH_O, NULL},
	 { "AttributeTypeListMap___setitem__", _wrap_AttributeTypeListMap___setitem__, METH_VARARGS, NULL},
	 { "AttributeTypeListMap_asdict", _wrap_AttributeTypeListMap_asdict, METH_O, NULL},
	 { "new_AttributeTypeListMap", _wrap_new_AttributeTypeListMap, METH_VARARGS, NULL},
	 { "AttributeTypeListMap_empty", _wrap_AttributeTypeListMap_empty, METH_O, NULL},
	 { "AttributeTypeListMap_size", _wrap_AttributeTypeListMap_size, METH_O, NULL},
	 { "AttributeTypeListMap_swap", _wrap_AttributeTypeListMap_swap, METH_VARARGS, NULL},
	 { "AttributeTypeListMap_begin", _wrap_AttributeTypeListMap_begin, METH_O, NULL},
	 { "AttributeTypeListMap_end", _wrap_AttributeTypeListMap_end, METH_O, NULL},
	 { "AttributeTypeListMap_rbegin", _wrap_AttributeTypeListMap_rbegin, METH_O, NULL},
	 { "AttributeTypeListMap_rend", _wrap_AttributeTypeListMap_rend, METH_O, NULL},
	 { "AttributeTypeListMap_clear", _wrap_AttributeTypeListMap_clear, METH_O, NULL},
	 { "AttributeTypeListMap_get_allocator", _wrap_AttributeTypeListMap_get_allocator, METH_O, NULL},
	 { "AttributeTypeListMap_count", _wrap_AttributeTypeListMap_count, METH_VARARGS, NULL},
	 { "AttributeTypeListMap_erase", _wrap_AttributeTypeListMap_erase, METH_VARARGS, NULL},
	 { "AttributeTypeListMap_find", _wrap_AttributeTypeListMap_find, METH_VARARGS, NULL},
	 { "AttributeTypeListMap_lower_bound", _wrap_AttributeTypeListMap_lower_bound, METH_VARARGS, NULL},
	 { "AttributeTypeListMap_upper_bound", _wrap_AttributeTypeListMap_upper_bound, METH_VARARGS, NULL},
	 { "delete_AttributeTypeListMap", _wrap_delete_AttributeTypeListMap, METH_O, NULL},
	 { "AttributeTypeListMap_swigregister", AttributeTypeListMap_swigregister, METH_O, NULL},
	 { "AttributeTypeListMap_swiginit", AttributeTypeListMap_swiginit, METH_VARARGS, NULL},
	 { "PyConfigEntMap_iterator", _wrap_PyConfigEntMap_iterator, METH_O, NULL},
	 { "PyConfigEntMap___nonzero__", _wrap_PyConfigEntMap___nonzero__, METH_O, NULL},
	 { "PyConfigEntMap___bool__", _wrap_PyConfigEntMap___bool__, METH_O, NULL},
	 { "PyConfigEntMap___len__", _wrap_PyConfigEntMap___len__, METH_O, NULL},
	 { "PyConfigEntMap___getitem__", _wrap_PyConfigEntMap___getitem__, METH_VARARGS, NULL},
	 { "PyConfigEntMap___delitem__", _wrap_PyConfigEntMap___delitem__, METH_VARARGS, NULL},
	 { "PyConfigEntMap_has_key", _wrap_PyConfigEntMap_has_key, METH_VARARGS, NULL},
	 { "PyConfigEntMap_keys", _wrap_PyConfigEntMap_keys, METH_O, NULL},
	 { "PyConfigEntMap_values", _wrap_PyConfigEntMap_values, METH_O, NULL},
	 { "PyConfigEntMap_items", _wrap_PyConfigEntMap_items, METH_O, NULL},
	 { "PyConfigEntMap___contains__", _wrap_PyConfigEntMap___contains__, METH_VARARGS, NULL},
	 { "PyConfigEntMap_key_iterator", _wrap_PyConfigEntMap_key_iterator, METH_O, NULL},
	 { "PyConfigEntMap_value_iterator", _wrap_PyConfigEntMap_value_iterator, METH_O, NULL},
	 { "PyConfigEntMap___setitem__", _wrap_PyConfigEntMap___setitem__, METH_VARARGS, NULL},
	 { "new_PyConfigEntMap", _wrap_new_PyConfigEntMap, METH_VARARGS, NULL},
	 { "PyConfigEntMap_empty", _wrap_PyConfigEntMap_empty, METH_O, NULL},
	 { "PyConfigEntMap_size", _wrap_PyConfigEntMap_size, METH_O, NULL},
	 { "PyConfigEntMap_swap", _wrap_PyConfigEntMap_swap, METH_VARARGS, NULL},
	 { "PyConfigEntMap_begin", _wrap_PyConfigEntMap_begin, METH_O, NULL},
	 { "PyConfigEntMap_end", _wrap_PyConfigEntMap_end, METH_O, NULL},
	 { "PyConfigEntMap_rbegin", _wrap_PyConfigEntMap_rbegin, METH_O, NULL},
	 { "PyConfigEntMap_rend", _wrap_PyConfigEntMap_rend, METH_O, NULL},
	 { "PyConfigEntMap_clear", _wrap_PyConfigEntMap_clear, METH_O, NULL},
	 { "PyConfigEntMap_get_allocator", _wrap_PyConfigEntMap_get_allocator, METH_O, NULL},
	 { "PyConfigEntMap_count", _wrap_PyConfigEntMap_count, METH_VARARGS, NULL},
	 { "PyConfigEntMap_erase", _wrap_PyConfigEntMap_erase, METH_VARARGS, NULL},
	 { "PyConfigEntMap_find", _wrap_PyConfigEntMap_find, METH_VARARGS, NULL},
	 { "PyConfigEntMap_lower_bound", _wrap_PyConfigEntMap_lower_bound, METH_VARARGS, NULL},
	 { "PyConfigEntMap_upper_bound", _wrap_PyConfigEntMap_upper_bound, METH_VARARGS, NULL},
	 { "PyConfigEntMap_equal_range", _wrap_PyConfigEntMap_equal_range, METH_VARARGS, NULL},
	 { "delete_PyConfigEntMap", _wrap_delete_PyConfigEntMap, METH_O, NULL},
	 { "PyConfigEntMap_swigregister", PyConfigEntMap_swigregister, METH_O, NULL},
	 { "PyConfigEntMap_swiginit", PyConfigEntMap_swiginit, METH_VARARGS, NULL},
	 { "PySectionMap_iterator", _wrap_PySectionMap_iterator, METH_O, NULL},
	 { "PySectionMap___nonzero__", _wrap_PySectionMap___nonzero__, METH_O, NULL},
	 { "PySectionMap___bool__", _wrap_PySectionMap___bool__, METH_O, NULL},
	 { "PySectionMap___len__", _wrap_PySectionMap___len__, METH_O, NULL},
	 { "PySectionMap___getitem__", _wrap_PySectionMap___getitem__, METH_VARARGS, NULL},
	 { "PySectionMap___delitem__", _wrap_PySectionMap___delitem__, METH_VARARGS, NULL},
	 { "PySectionMap_has_key", _wrap_PySectionMap_has_key, METH_VARARGS, NULL},
	 { "PySectionMap_keys", _wrap_PySectionMap_keys, METH_O, NULL},
	 { "PySectionMap_values", _wrap_PySectionMap_values, METH_O, NULL},
	 { "PySectionMap_items", _wrap_PySectionMap_items, METH_O, NULL},
	 { "PySectionMap___contains__", _wrap_PySectionMap___contains__, METH_VARARGS, NULL},
	 { "PySectionMap_key_iterator", _wrap_PySectionMap_key_iterator, METH_O, NULL},
	 { "PySectionMap_value_iterator", _wrap_PySectionMap_value_iterator, METH_O, NULL},
	 { "PySectionMap___setitem__", _wrap_PySectionMap___setitem__, METH_VARARGS, NULL},
	 { "PySectionMap_asdict", _wrap_PySectionMap_asdict, METH_O, NULL},
	 { "new_PySectionMap", _wrap_new_PySectionMap, METH_VARARGS, NULL},
	 { "PySectionMap_empty", _wrap_PySectionMap_empty, METH_O, NULL},
	 { "PySectionMap_size", _wrap_PySectionMap_size, METH_O, NULL},
	 { "PySectionMap_swap", _wrap_PySectionMap_swap, METH_VARARGS, NULL},
	 { "PySectionMap_begin", _wrap_PySectionMap_begin, METH_O, NULL},
	 { "PySectionMap_end", _wrap_PySectionMap_end, METH_O, NULL},
	 { "PySectionMap_rbegin", _wrap_PySectionMap_rbegin, METH_O, NULL},
	 { "PySectionMap_rend", _wrap_PySectionMap_rend, METH_O, NULL},
	 { "PySectionMap_clear", _wrap_PySectionMap_clear, METH_O, NULL},
	 { "PySectionMap_get_allocator", _wrap_PySectionMap_get_allocator, METH_O, NULL},
	 { "PySectionMap_count", _wrap_PySectionMap_count, METH_VARARGS, NULL},
	 { "PySectionMap_erase", _wrap_PySectionMap_erase, METH_VARARGS, NULL},
	 { "PySectionMap_find", _wrap_PySectionMap_find, METH_VARARGS, NULL},
	 { "PySectionMap_lower_bound", _wrap_PySectionMap_lower_bound, METH_VARARGS, NULL},
	 { "PySectionMap_upper_bound", _wrap_PySectionMap_upper_bound, METH_VARARGS, NULL},
	 { "delete_PySectionMap", _wrap_delete_PySectionMap, METH_O, NULL},
	 { "PySectionMap_swigregister", PySectionMap_swigregister, METH_O, NULL},
	 { "PySectionMap_swiginit", PySectionMap_swiginit, METH_VARARGS, NULL},
	 { "ModuleMap_iterator", _wrap_ModuleMap_iterator, METH_O, NULL},
	 { "ModuleMap___nonzero__", _wrap_ModuleMap___nonzero__, METH_O, NULL},
	 { "ModuleMap___bool__", _wrap_ModuleMap___bool__, METH_O, NULL},
	 { "ModuleMap___len__", _wrap_ModuleMap___len__, METH_O, NULL},
	 { "ModuleMap___getitem__", _wrap_ModuleMap___getitem__, METH_VARARGS, NULL},
	 { "ModuleMap___delitem__", _wrap_ModuleMap___delitem__, METH_VARARGS, NULL},
	 { "ModuleMap_has_key", _wrap_ModuleMap_has_key, METH_VARARGS, NULL},
	 { "ModuleMap_keys", _wrap_ModuleMap_keys, METH_O, NULL},
	 { "ModuleMap_values", _wrap_ModuleMap_values, METH_O, NULL},
	 { "ModuleMap_items", _wrap_ModuleMap_items, METH_O, NULL},
	 { "ModuleMap___contains__", _wrap_ModuleMap___contains__, METH_VARARGS, NULL},
	 { "ModuleMap_key_iterator", _wrap_ModuleMap_key_iterator, METH_O, NULL},
	 { "ModuleMap_value_iterator", _wrap_ModuleMap_value_iterator, METH_O, NULL},
	 { "ModuleMap___setitem__", _wrap_ModuleMap___setitem__, METH_VARARGS, NULL},
	 { "ModuleMap_asdict", _wrap_ModuleMap_asdict, METH_O, NULL},
	 { "new_ModuleMap", _wrap_new_ModuleMap, METH_VARARGS, NULL},
	 { "ModuleMap_empty", _wrap_ModuleMap_empty, METH_O, NULL},
	 { "ModuleMap_size", _wrap_ModuleMap_size, METH_O, NULL},
	 { "ModuleMap_swap", _wrap_ModuleMap_swap, METH_VARARGS, NULL},
	 { "ModuleMap_begin", _wrap_ModuleMap_begin, METH_O, NULL},
	 { "ModuleMap_end", _wrap_ModuleMap_end, METH_O, NULL},
	 { "ModuleMap_rbegin", _wrap_ModuleMap_rbegin, METH_O, NULL},
	 { "ModuleMap_rend", _wrap_ModuleMap_rend, METH_O, NULL},
	 { "ModuleMap_clear", _wrap_ModuleMap_clear, METH_O, NULL},
	 { "ModuleMap_get_allocator", _wrap_ModuleMap_get_allocator, METH_O, NULL},
	 { "ModuleMap_count", _wrap_ModuleMap_count, METH_VARARGS, NULL},
	 { "ModuleMap_erase", _wrap_ModuleMap_erase, METH_VARARGS, NULL},
	 { "ModuleMap_find", _wrap_ModuleMap_find, METH_VARARGS, NULL},
	 { "ModuleMap_lower_bound", _wrap_ModuleMap_lower_bound, METH_VARARGS, NULL},
	 { "ModuleMap_upper_bound", _wrap_ModuleMap_upper_bound, METH_VARARGS, NULL},
	 { "delete_ModuleMap", _wrap_delete_ModuleMap, METH_O, NULL},
	 { "ModuleMap_swigregister", ModuleMap_swigregister, METH_O, NULL},
	 { "ModuleMap_swiginit", ModuleMap_swiginit, METH_VARARGS, NULL},
	 { "StringVector_iterator", _wrap_StringVector_iterator, METH_O, NULL},
	 { "StringVector___nonzero__", _wrap_StringVector___nonzero__, METH_O, NULL},
	 { "StringVector___bool__", _wrap_StringVector___bool__, METH_O, NULL},
	 { "StringVector___len__", _wrap_StringVector___len__, METH_O, NULL},
	 { "StringVector___getslice__", _wrap_StringVector___getslice__, METH_VARARGS, NULL},
	 { "StringVector___setslice__", _wrap_StringVector___setslice__, METH_VARARGS, NULL},
	 { "StringVector___delslice__", _wrap_StringVector___delslice__, METH_VARARGS, NULL},
	 { "StringVector___delitem__", _wrap_StringVector___delitem__, METH_VARARGS, NULL},
	 { "StringVector___getitem__", _wrap_StringVector___getitem__, METH_VARARGS, NULL},
	 { "StringVector___setitem__", _wrap_StringVector___setitem__, METH_VARARGS, NULL},
	 { "StringVector_pop", _wrap_StringVector_pop, METH_O, NULL},
	 { "StringVector_append", _wrap_StringVector_append, METH_VARARGS, NULL},
	 { "StringVector_empty", _wrap_StringVector_empty, METH_O, NULL},
	 { "StringVector_size", _wrap_StringVector_size, METH_O, NULL},
	 { "StringVector_swap", _wrap_StringVector_swap, METH_VARARGS, NULL},
	 { "StringVector_begin", _wrap_StringVector_begin, METH_O, NULL},
	 { "StringVector_end", _wrap_StringVector_end, METH_O, NULL},
	 { "StringVector_rbegin", _wrap_StringVector_rbegin, METH_O, NULL},
	 { "StringVector_rend", _wrap_StringVector_rend, METH_O, NULL},
	 { "StringVector_clear", _wrap_StringVector_clear, METH_O, NULL},
	 { "StringVector_get_allocator", _wrap_StringVector_get_allocator, METH_O, NULL},
	 { "StringVector_pop_back", _wrap_StringVector_pop_back, METH_O, NULL},
	 { "StringVector_erase", _wrap_StringVector_erase, METH_VARARGS, NULL},
	 { "new_StringVector", _wrap_new_StringVector, METH_VARARGS, NULL},
	 { "StringVector_push_back", _wrap_StringVector_push_back, METH_VARARGS, NULL},
	 { "StringVector_front", _wrap_StringVector_front, METH_O, NULL},
	 { "StringVector_back", _wrap_StringVector_back, METH_O, NULL},
	 { "StringVector_assign", _wrap_StringVector_assign, METH_VARARGS, NULL},
	 { "StringVector_resize", _wrap_StringVector_resize, METH_VARARGS, NULL},
	 { "StringVector_insert", _wrap_StringVector_insert, METH_VARARGS, NULL},
	 { "StringVector_reserve", _wrap_StringVector_reserve, METH_VARARGS, NULL},
	 { "StringVector_capacity", _wrap_StringVector_capacity, METH_O, NULL},
	 { "delete_StringVector", _wrap_delete_StringVector, METH_O, NULL},
	 { "StringVector_swigregister", StringVector_swigregister, METH_O, NULL},
	 { "StringVector_swiginit", StringVector_swiginit, METH_VARARGS, NULL},
	 { "StringList_iterator", _wrap_StringList_iterator, METH_O, NULL},
	 { "StringList___nonzero__", _wrap_StringList___nonzero__, METH_O, NULL},
	 { "StringList___bool__", _wrap_StringList___bool__, METH_O, NULL},
	 { "StringList___len__", _wrap_StringList___len__, METH_O, NULL},
	 { "StringList___getslice__", _wrap_StringList___getslice__, METH_VARARGS, NULL},
	 { "StringList___setslice__", _wrap_StringList___setslice__, METH_VARARGS, NULL},
	 { "StringList___delslice__", _wrap_StringList___delslice__, METH_VARARGS, NULL},
	 { "StringList___delitem__", _wrap_StringList___delitem__, METH_VARARGS, NULL},
	 { "StringList___getitem__", _wrap_StringList___getitem__, METH_VARARGS, NULL},
	 { "StringList___setitem__", _wrap_StringList___setitem__, METH_VARARGS, NULL},
	 { "StringList_pop", _wrap_StringList_pop, METH_O, NULL},
	 { "StringList_append", _wrap_StringList_append, METH_VARARGS, NULL},
	 { "StringList_empty", _wrap_StringList_empty, METH_O, NULL},
	 { "StringList_size", _wrap_StringList_size, METH_O, NULL},
	 { "StringList_swap", _wrap_StringList_swap, METH_VARARGS, NULL},
	 { "StringList_begin", _wrap_StringList_begin, METH_O, NULL},
	 { "StringList_end", _wrap_StringList_end, METH_O, NULL},
	 { "StringList_rbegin", _wrap_StringList_rbegin, METH_O, NULL},
	 { "StringList_rend", _wrap_StringList_rend, METH_O, NULL},
	 { "StringList_clear", _wrap_StringList_clear, METH_O, NULL},
	 { "StringList_get_allocator", _wrap_StringList_get_allocator, METH_O, NULL},
	 { "StringList_pop_back", _wrap_StringList_pop_back, METH_O, NULL},
	 { "StringList_erase", _wrap_StringList_erase, METH_VARARGS, NULL},
	 { "new_StringList", _wrap_new_StringList, METH_VARARGS, NULL},
	 { "StringList_push_back", _wrap_StringList_push_back, METH_VARARGS, NULL},
	 { "StringList_front", _wrap_StringList_front, METH_O, NULL},
	 { "StringList_back", _wrap_StringList_back, METH_O, NULL},
	 { "StringList_assign", _wrap_StringList_assign, METH_VARARGS, NULL},
	 { "StringList_resize", _wrap_StringList_resize, METH_VARARGS, NULL},
	 { "StringList_insert", _wrap_StringList_insert, METH_VARARGS, NULL},
	 { "StringList_pop_front", _wrap_StringList_pop_front, METH_O, NULL},
	 { "StringList_push_front", _wrap_StringList_push_front, METH_VARARGS, NULL},
	 { "StringList_reverse", _wrap_StringList_reverse, METH_O, NULL},
	 { "delete_StringList", _wrap_delete_StringList, METH_O, NULL},
	 { "StringList_swigregister", StringList_swigregister, METH_O, NULL},
	 { "StringList_swiginit", StringList_swiginit, METH_VARARGS, NULL},
	 { "InstallSourceMap_iterator", _wrap_InstallSourceMap_iterator, METH_O, NULL},
	 { "InstallSourceMap___nonzero__", _wrap_InstallSourceMap___nonzero__, METH_O, NULL},
	 { "InstallSourceMap___bool__", _wrap_InstallSourceMap___bool__, METH_O, NULL},
	 { "InstallSourceMap___len__", _wrap_InstallSourceMap___len__, METH_O, NULL},
	 { "InstallSourceMap___getitem__", _wrap_InstallSourceMap___getitem__, METH_VARARGS, NULL},
	 { "InstallSourceMap___delitem__", _wrap_InstallSourceMap___delitem__, METH_VARARGS, NULL},
	 { "InstallSourceMap_has_key", _wrap_InstallSourceMap_has_key, METH_VARARGS, NULL},
	 { "InstallSourceMap_keys", _wrap_InstallSourceMap_keys, METH_O, NULL},
	 { "InstallSourceMap_values", _wrap_InstallSourceMap_values, METH_O, NULL},
	 { "InstallSourceMap_items", _wrap_InstallSourceMap_items, METH_O, NULL},
	 { "InstallSourceMap___contains__", _wrap_InstallSourceMap___contains__, METH_VARARGS, NULL},
	 { "InstallSourceMap_key_iterator", _wrap_InstallSourceMap_key_iterator, METH_O, NULL},
	 { "InstallSourceMap_value_iterator", _wrap_InstallSourceMap_value_iterator, METH_O, NULL},
	 { "InstallSourceMap___setitem__", _wrap_InstallSourceMap___setitem__, METH_VARARGS, NULL},
	 { "InstallSourceMap_asdict", _wrap_InstallSourceMap_asdict, METH_O, NULL},
	 { "new_InstallSourceMap", _wrap_new_InstallSourceMap, METH_VARARGS, NULL},
	 { "InstallSourceMap_empty", _wrap_InstallSourceMap_empty, METH_O, NULL},
	 { "InstallSourceMap_size", _wrap_InstallSourceMap_size, METH_O, NULL},
	 { "InstallSourceMap_swap", _wrap_InstallSourceMap_swap, METH_VARARGS, NULL},
	 { "InstallSourceMap_begin", _wrap_InstallSourceMap_begin, METH_O, NULL},
	 { "InstallSourceMap_end", _wrap_InstallSourceMap_end, METH_O, NULL},
	 { "InstallSourceMap_rbegin", _wrap_InstallSourceMap_rbegin, METH_O, NULL},
	 { "InstallSourceMap_rend", _wrap_InstallSourceMap_rend, METH_O, NULL},
	 { "InstallSourceMap_clear", _wrap_InstallSourceMap_clear, METH_O, NULL},
	 { "InstallSourceMap_get_allocator", _wrap_InstallSourceMap_get_allocator, METH_O, NULL},
	 { "InstallSourceMap_count", _wrap_InstallSourceMap_count, METH_VARARGS, NULL},
	 { "InstallSourceMap_erase", _wrap_InstallSourceMap_erase, METH_VARARGS, NULL},
	 { "InstallSourceMap_find", _wrap_InstallSourceMap_find, METH_VARARGS, NULL},
	 { "InstallSourceMap_lower_bound", _wrap_InstallSourceMap_lower_bound, METH_VARARGS, NULL},
	 { "InstallSourceMap_upper_bound", _wrap_InstallSourceMap_upper_bound, METH_VARARGS, NULL},
	 { "delete_InstallSourceMap", _wrap_delete_InstallSourceMap, METH_O, NULL},
	 { "InstallSourceMap_swigregister", InstallSourceMap_swigregister, METH_O, NULL},
	 { "InstallSourceMap_swiginit", InstallSourceMap_swiginit, METH_VARARGS, NULL},
	 { "DirEntryVector_iterator", _wrap_DirEntryVector_iterator, METH_O, NULL},
	 { "DirEntryVector___nonzero__", _wrap_DirEntryVector___nonzero__, METH_O, NULL},
	 { "DirEntryVector___bool__", _wrap_DirEntryVector___bool__, METH_O, NULL},
	 { "DirEntryVector___len__", _wrap_DirEntryVector___len__, METH_O, NULL},
	 { "DirEntryVector___getslice__", _wrap_DirEntryVector___getslice__, METH_VARARGS, NULL},
	 { "DirEntryVector___setslice__", _wrap_DirEntryVector___setslice__, METH_VARARGS, NULL},
	 { "DirEntryVector___delslice__", _wrap_DirEntryVector___delslice__, METH_VARARGS, NULL},
	 { "DirEntryVector___delitem__", _wrap_DirEntryVector___delitem__, METH_VARARGS, NULL},
	 { "DirEntryVector___getitem__", _wrap_DirEntryVector___getitem__, METH_VARARGS, NULL},
	 { "DirEntryVector___setitem__", _wrap_DirEntryVector___setitem__, METH_VARARGS, NULL},
	 { "DirEntryVector_pop", _wrap_DirEntryVector_pop, METH_O, NULL},
	 { "DirEntryVector_append", _wrap_DirEntryVector_append, METH_VARARGS, NULL},
	 { "DirEntryVector_empty", _wrap_DirEntryVector_empty, METH_O, NULL},
	 { "DirEntryVector_size", _wrap_DirEntryVector_size, METH_O, NULL},
	 { "DirEntryVector_swap", _wrap_DirEntryVector_swap, METH_VARARGS, NULL},
	 { "DirEntryVector_begin", _wrap_DirEntryVector_begin, METH_O, NULL},
	 { "DirEntryVector_end", _wrap_DirEntryVector_end, METH_O, NULL},
	 { "DirEntryVector_rbegin", _wrap_DirEntryVector_rbegin, METH_O, NULL},
	 { "DirEntryVector_rend", _wrap_DirEntryVector_rend, METH_O, NULL},
	 { "DirEntryVector_clear", _wrap_DirEntryVector_clear, METH_O, NULL},
	 { "DirEntryVector_get_allocator", _wrap_DirEntryVector_get_allocator, METH_O, NULL},
	 { "DirEntryVector_pop_back", _wrap_DirEntryVector_pop_back, METH_O, NULL},
	 { "DirEntryVector_erase", _wrap_DirEntryVector_erase, METH_VARARGS, NULL},
	 { "new_DirEntryVector", _wrap_new_DirEntryVector, METH_VARARGS, NULL},
	 { "DirEntryVector_push_back", _wrap_DirEntryVector_push_back, METH_VARARGS, NULL},
	 { "DirEntryVector_front", _wrap_DirEntryVector_front, METH_O, NULL},
	 { "DirEntryVector_back", _wrap_DirEntryVector_back, METH_O, NULL},
	 { "DirEntryVector_assign", _wrap_DirEntryVector_assign, METH_VARARGS, NULL},
	 { "DirEntryVector_resize", _wrap_DirEntryVector_resize, METH_VARARGS, NULL},
	 { "DirEntryVector_insert", _wrap_DirEntryVector_insert, METH_VARARGS, NULL},
	 { "DirEntryVector_reserve", _wrap_DirEntryVector_reserve, METH_VARARGS, NULL},
	 { "DirEntryVector_capacity", _wrap_DirEntryVector_capacity, METH_O, NULL},
	 { "delete_DirEntryVector", _wrap_delete_DirEntryVector, METH_O, NULL},
	 { "DirEntryVector_swigregister", DirEntryVector_swigregister, METH_O, NULL},
	 { "DirEntryVector_swiginit", DirEntryVector_swiginit, METH_VARARGS, NULL},
	 { "SWClass_isAssignableFrom", _wrap_SWClass_isAssignableFrom, METH_VARARGS, NULL},
	 { "delete_SWClass", _wrap_delete_SWClass, METH_O, NULL},
	 { "SWClass_swigregister", SWClass_swigregister, METH_O, NULL},
	 { "new_SWObject", _wrap_new_SWObject, METH_O, NULL},
	 { "SWObject_getClass", _wrap_SWObject_getClass, METH_O, NULL},
	 { "delete_SWObject", _wrap_delete_SWObject, METH_O, NULL},
	 { "SWObject_swigregister", SWObject_swigregister, METH_O, NULL},
	 { "SWObject_swiginit", SWObject_swiginit, METH_VARARGS, NULL},
	 { "new_SWConfig", _wrap_new_SWConfig, METH_VARARGS, NULL},
	 { "delete_SWConfig", _wrap_delete_SWConfig, METH_O, NULL},
	 { "SWConfig_getSections", _wrap_SWConfig_getSections, METH_O, NULL},
	 { "SWConfig_load", _wrap_SWConfig_load, METH_O, NULL},
	 { "SWConfig_save", _wrap_SWConfig_save, METH_O, NULL},
	 { "SWConfig_augment", _wrap_SWConfig_augment, METH_VARARGS, NULL},
	 { "SWConfig_getSection", _wrap_SWConfig_getSection, METH_VARARGS, NULL},
	 { "SWConfig_getValue", _wrap_SWConfig_getValue, METH_VARARGS, NULL},
	 { "SWConfig_setValue", _wrap_SWConfig_setValue, METH_VARARGS, NULL},
	 { "SWConfig_getFileName", _wrap_SWConfig_getFileName, METH_O, NULL},
	 { "SWConfig_set", _wrap_SWConfig_set, METH_VARARGS, NULL},
	 { "SWConfig_get", _wrap_SWConfig_get, METH_VARARGS, NULL},
	 { "SWConfig_swigregister", SWConfig_swigregister, METH_O, NULL},
	 { "SWConfig_swiginit", SWConfig_swiginit, METH_VARARGS, NULL},
	 { "SWVersion_major_set", _wrap_SWVersion_major_set, METH_VARARGS, NULL},
	 { "SWVersion_major_get", _wrap_SWVersion_major_get, METH_O, NULL},
	 { "SWVersion_minor_set", _wrap_SWVersion_minor_set, METH_VARARGS, NULL},
	 { "SWVersion_minor_get", _wrap_SWVersion_minor_get, METH_O, NULL},
	 { "SWVersion_minor2_set", _wrap_SWVersion_minor2_set, METH_VARARGS, NULL},
	 { "SWVersion_minor2_get", _wrap_SWVersion_minor2_get, METH_O, NULL},
	 { "SWVersion_minor3_set", _wrap_SWVersion_minor3_set, METH_VARARGS, NULL},
	 { "SWVersion_minor3_get", _wrap_SWVersion_minor3_get, METH_O, NULL},
	 { "new_SWVersion", _wrap_new_SWVersion, METH_VARARGS, NULL},
	 { "SWVersion_compare", _wrap_SWVersion_compare, METH_VARARGS, NULL},
	 { "SWVersion_getText", _wrap_SWVersion_getText, METH_O, NULL},
	 { "SWVersion___gt__", _wrap_SWVersion___gt__, METH_VARARGS, NULL},
	 { "SWVersion___lt__", _wrap_SWVersion___lt__, METH_VARARGS, NULL},
	 { "SWVersion___ge__", _wrap_SWVersion___ge__, METH_VARARGS, NULL},
	 { "SWVersion___le__", _wrap_SWVersion___le__, METH_VARARGS, NULL},
	 { "SWVersion___eq__", _wrap_SWVersion___eq__, METH_VARARGS, NULL},
	 { "SWVersion_currentVersion_get", _wrap_SWVersion_currentVersion_get, METH_VARARGS, NULL},
	 { "SWVersion_currentVersion_set", _wrap_SWVersion_currentVersion_set, METH_O, NULL},
	 { "delete_SWVersion", _wrap_delete_SWVersion, METH_O, NULL},
	 { "SWVersion_swigregister", SWVersion_swigregister, METH_O, NULL},
	 { "SWVersion_swiginit", SWVersion_swiginit, METH_VARARGS, NULL},
	 { "new_RawVerse", _wrap_new_RawVerse, METH_VARARGS, NULL},
	 { "delete_RawVerse", _wrap_delete_RawVerse, METH_O, NULL},
	 { "RawVerse_findOffset", _wrap_RawVerse_findOffset, METH_VARARGS, NULL},
	 { "RawVerse_readText", _wrap_RawVerse_readText, METH_VARARGS, NULL},
	 { "RawVerse_createModule", _wrap_RawVerse_createModule, METH_VARARGS, NULL},
	 { "RawVerse_swigregister", RawVerse_swigregister, METH_O, NULL},
	 { "RawVerse_swiginit", RawVerse_swiginit, METH_VARARGS, NULL},
	 { "new_zVerse", _wrap_new_zVerse, METH_VARARGS, NULL},
	 { "delete_zVerse", _wrap_delete_zVerse, METH_O, NULL},
	 { "zVerse_findOffset", _wrap_zVerse_findOffset, METH_VARARGS, NULL},
	 { "zVerse_zReadText", _wrap_zVerse_zReadText, METH_VARARGS, NULL},
	 { "zVerse_rawZFilter", _wrap_zVerse_rawZFilter, METH_VARARGS, NULL},
	 { "zVerse_createModule", _wrap_zVerse_createModule, METH_VARARGS, NULL},
	 { "zVerse_swigregister", zVerse_swigregister, METH_O, NULL},
	 { "zVerse_swiginit", zVerse_swiginit, METH_VARARGS, NULL},
	 { "new_RawStr", _wrap_new_RawStr, METH_VARARGS, NULL},
	 { "delete_RawStr", _wrap_delete_RawStr, METH_O, NULL},
	 { "RawStr_getIDXBuf", _wrap_RawStr_getIDXBuf, METH_VARARGS, NULL},
	 { "RawStr_getIDXBufDat", _wrap_RawStr_getIDXBufDat, METH_VARARGS, NULL},
	 { "RawStr_findOffset", _wrap_RawStr_findOffset, METH_VARARGS, NULL},
	 { "RawStr_readText", _wrap_RawStr_readText, METH_VARARGS, NULL},
	 { "RawStr_createModule", _wrap_RawStr_createModule, METH_O, NULL},
	 { "RawStr_swigregister", RawStr_swigregister, METH_O, NULL},
	 { "RawStr_swiginit", RawStr_swiginit, METH_VARARGS, NULL},
	 { "new_RawStr4", _wrap_new_RawStr4, METH_VARARGS, NULL},
	 { "delete_RawStr4", _wrap_delete_RawStr4, METH_O, NULL},
	 { "RawStr4_getIDXBuf", _wrap_RawStr4_getIDXBuf, METH_VARARGS, NULL},
	 { "RawStr4_getIDXBufDat", _wrap_RawStr4_getIDXBufDat, METH_VARARGS, NULL},
	 { "RawStr4_findOffset", _wrap_RawStr4_findOffset, METH_VARARGS, NULL},
	 { "RawStr4_readText", _wrap_RawStr4_readText, METH_VARARGS, NULL},
	 { "RawStr4_createModule", _wrap_RawStr4_createModule, METH_O, NULL},
	 { "RawStr4_swigregister", RawStr4_swigregister, METH_O, NULL},
	 { "RawStr4_swiginit", RawStr4_swiginit, METH_VARARGS, NULL},
	 { "new_zStr", _wrap_new_zStr, METH_VARARGS, NULL},
	 { "delete_zStr", _wrap_delete_zStr, METH_O, NULL},
	 { "zStr_findKeyIndex", _wrap_zStr_findKeyIndex, METH_VARARGS, NULL},
	 { "zStr_getText", _wrap_zStr_getText, METH_VARARGS, NULL},
	 { "zStr_setText", _wrap_zStr_setText, METH_VARARGS, NULL},
	 { "zStr_linkEntry", _wrap_zStr_linkEntry, METH_VARARGS, NULL},
	 { "zStr_rawZFilter", _wrap_zStr_rawZFilter, METH_VARARGS, NULL},
	 { "zStr_createModule", _wrap_zStr_createModule, METH_O, NULL},
	 { "zStr_swigregister", zStr_swigregister, METH_O, NULL},
	 { "zStr_swiginit", zStr_swiginit, METH_VARARGS, NULL},
	 { "new_SW_POSITION", _wrap_new_SW_POSITION, METH_O, NULL},
	 { "SW_POSITION_getPosition", _wrap_SW_POSITION_getPosition, METH_O, NULL},
	 { "delete_SW_POSITION", _wrap_delete_SW_POSITION, METH_O, NULL},
	 { "SW_POSITION_swigregister", SW_POSITION_swigregister, METH_O, NULL},
	 { "SW_POSITION_swiginit", SW_POSITION_swiginit, METH_VARARGS, NULL},
	 { "new_SWKey", _wrap_new_SWKey, METH_VARARGS, NULL},
	 { "delete_SWKey", _wrap_delete_SWKey, METH_O, NULL},
	 { "SWKey_clone", _wrap_SWKey_clone, METH_O, NULL},
	 { "SWKey_isPersist", _wrap_SWKey_isPersist, METH_O, NULL},
	 { "SWKey_setPersist", _wrap_SWKey_setPersist, METH_VARARGS, NULL},
	 { "SWKey_popError", _wrap_SWKey_popError, METH_O, NULL},
	 { "SWKey_getError", _wrap_SWKey_getError, METH_O, NULL},
	 { "SWKey_setError", _wrap_SWKey_setError, METH_VARARGS, NULL},
	 { "SWKey_setText", _wrap_SWKey_setText, METH_VARARGS, NULL},
	 { "SWKey_copyFrom", _wrap_SWKey_copyFrom, METH_VARARGS, NULL},
	 { "SWKey_positionFrom", _wrap_SWKey_positionFrom, METH_VARARGS, NULL},
	 { "SWKey_getText", _wrap_SWKey_getText, METH_O, NULL},
	 { "SWKey_getShortText", _wrap_SWKey_getShortText, METH_O, NULL},
	 { "SWKey_getRangeText", _wrap_SWKey_getRangeText, METH_O, NULL},
	 { "SWKey_getShortRangeText", _wrap_SWKey_getShortRangeText, METH_O, NULL},
	 { "SWKey_getOSISRefRangeText", _wrap_SWKey_getOSISRefRangeText, METH_O, NULL},
	 { "SWKey_isBoundSet", _wrap_SWKey_isBoundSet, METH_O, NULL},
	 { "SWKey_clearBounds", _wrap_SWKey_clearBounds, METH_O, NULL},
	 { "SWKey_compare", _wrap_SWKey_compare, METH_VARARGS, NULL},
	 { "SWKey_equals", _wrap_SWKey_equals, METH_VARARGS, NULL},
	 { "SWKey_setPosition", _wrap_SWKey_setPosition, METH_VARARGS, NULL},
	 { "SWKey_decrement", _wrap_SWKey_decrement, METH_VARARGS, NULL},
	 { "SWKey_increment", _wrap_SWKey_increment, METH_VARARGS, NULL},
	 { "SWKey_isTraversable", _wrap_SWKey_isTraversable, METH_O, NULL},
	 { "SWKey_getLocale", _wrap_SWKey_getLocale, METH_O, NULL},
	 { "SWKey_setLocale", _wrap_SWKey_setLocale, METH_VARARGS, NULL},
	 { "SWKey_getIndex", _wrap_SWKey_getIndex, METH_O, NULL},
	 { "SWKey_setIndex", _wrap_SWKey_setIndex, METH_VARARGS, NULL},
	 { "SWKey___eq__", _wrap_SWKey___eq__, METH_VARARGS, NULL},
	 { "SWKey___ne__", _wrap_SWKey___ne__, METH_VARARGS, NULL},
	 { "SWKey___gt__", _wrap_SWKey___gt__, METH_VARARGS, NULL},
	 { "SWKey___lt__", _wrap_SWKey___lt__, METH_VARARGS, NULL},
	 { "SWKey___ge__", _wrap_SWKey___ge__, METH_VARARGS, NULL},
	 { "SWKey___le__", _wrap_SWKey___le__, METH_VARARGS, NULL},
	 { "SWKey___isub__", _wrap_SWKey___isub__, METH_VARARGS, NULL},
	 { "SWKey___iadd__", _wrap_SWKey___iadd__, METH_VARARGS, NULL},
	 { "SWKey_swigregister", SWKey_swigregister, METH_O, NULL},
	 { "SWKey_swiginit", SWKey_swiginit, METH_VARARGS, NULL},
	 { "new_ListKey", _wrap_new_ListKey, METH_VARARGS, NULL},
	 { "delete_ListKey", _wrap_delete_ListKey, METH_O, NULL},
	 { "ListKey_clone", _wrap_ListKey_clone, METH_O, NULL},
	 { "ListKey_clear", _wrap_ListKey_clear, METH_O, NULL},
	 { "ListKey_getCount", _wrap_ListKey_getCount, METH_O, NULL},
	 { "ListKey_remove", _wrap_ListKey_remove, METH_O, NULL},
	 { "ListKey_setToElement", _wrap_ListKey_setToElement, METH_VARARGS, NULL},
	 { "ListKey_getElement", _wrap_ListKey_getElement, METH_VARARGS, NULL},
	 { "ListKey_add", _wrap_ListKey_add, METH_VARARGS, NULL},
	 { "ListKey_copyFrom", _wrap_ListKey_copyFrom, METH_VARARGS, NULL},
	 { "ListKey_setPosition", _wrap_ListKey_setPosition, METH_VARARGS, NULL},
	 { "ListKey_decrement", _wrap_ListKey_decrement, METH_VARARGS, NULL},
	 { "ListKey_increment", _wrap_ListKey_increment, METH_VARARGS, NULL},
	 { "ListKey_nextElement", _wrap_ListKey_nextElement, METH_O, NULL},
	 { "ListKey_isTraversable", _wrap_ListKey_isTraversable, METH_O, NULL},
	 { "ListKey_getIndex", _wrap_ListKey_getIndex, METH_O, NULL},
	 { "ListKey_getRangeText", _wrap_ListKey_getRangeText, METH_O, NULL},
	 { "ListKey_getOSISRefRangeText", _wrap_ListKey_getOSISRefRangeText, METH_O, NULL},
	 { "ListKey_getShortRangeText", _wrap_ListKey_getShortRangeText, METH_O, NULL},
	 { "ListKey_getShortText", _wrap_ListKey_getShortText, METH_O, NULL},
	 { "ListKey_setIndex", _wrap_ListKey_setIndex, METH_VARARGS, NULL},
	 { "ListKey_getText", _wrap_ListKey_getText, METH_O, NULL},
	 { "ListKey_setText", _wrap_ListKey_setText, METH_VARARGS, NULL},
	 { "ListKey_sort", _wrap_ListKey_sort, METH_O, NULL},
	 { "ListKey___eq__", _wrap_ListKey___eq__, METH_VARARGS, NULL},
	 { "ListKey___ne__", _wrap_ListKey___ne__, METH_VARARGS, NULL},
	 { "ListKey___gt__", _wrap_ListKey___gt__, METH_VARARGS, NULL},
	 { "ListKey___lt__", _wrap_ListKey___lt__, METH_VARARGS, NULL},
	 { "ListKey___ge__", _wrap_ListKey___ge__, METH_VARARGS, NULL},
	 { "ListKey___le__", _wrap_ListKey___le__, METH_VARARGS, NULL},
	 { "ListKey___isub__", _wrap_ListKey___isub__, METH_VARARGS, NULL},
	 { "ListKey___iadd__", _wrap_ListKey___iadd__, METH_VARARGS, NULL},
	 { "ListKey_castTo", _wrap_ListKey_castTo, METH_O, NULL},
	 { "ListKey_swigregister", ListKey_swigregister, METH_O, NULL},
	 { "ListKey_swiginit", ListKey_swiginit, METH_VARARGS, NULL},
	 { "new_VerseKey", _wrap_new_VerseKey, METH_VARARGS, NULL},
	 { "delete_VerseKey", _wrap_delete_VerseKey, METH_O, NULL},
	 { "VerseKey_setLowerBound", _wrap_VerseKey_setLowerBound, METH_VARARGS, NULL},
	 { "VerseKey_setUpperBound", _wrap_VerseKey_setUpperBound, METH_VARARGS, NULL},
	 { "VerseKey_getLowerBound", _wrap_VerseKey_getLowerBound, METH_O, NULL},
	 { "VerseKey_getUpperBound", _wrap_VerseKey_getUpperBound, METH_O, NULL},
	 { "VerseKey_clearBounds", _wrap_VerseKey_clearBounds, METH_O, NULL},
	 { "VerseKey_clone", _wrap_VerseKey_clone, METH_O, NULL},
	 { "VerseKey_getText", _wrap_VerseKey_getText, METH_O, NULL},
	 { "VerseKey_getShortText", _wrap_VerseKey_getShortText, METH_O, NULL},
	 { "VerseKey_setText", _wrap_VerseKey_setText, METH_VARARGS, NULL},
	 { "VerseKey_copyFrom", _wrap_VerseKey_copyFrom, METH_VARARGS, NULL},
	 { "VerseKey_positionFrom", _wrap_VerseKey_positionFrom, METH_VARARGS, NULL},
	 { "VerseKey_setPosition", _wrap_VerseKey_setPosition, METH_VARARGS, NULL},
	 { "VerseKey_decrement", _wrap_VerseKey_decrement, METH_VARARGS, NULL},
	 { "VerseKey_increment", _wrap_VerseKey_increment, METH_VARARGS, NULL},
	 { "VerseKey_isTraversable", _wrap_VerseKey_isTraversable, METH_O, NULL},
	 { "VerseKey_getBookName", _wrap_VerseKey_getBookName, METH_O, NULL},
	 { "VerseKey_setBookName", _wrap_VerseKey_setBookName, METH_VARARGS, NULL},
	 { "VerseKey_getBookAbbrev", _wrap_VerseKey_getBookAbbrev, METH_O, NULL},
	 { "VerseKey_getTestament", _wrap_VerseKey_getTestament, METH_O, NULL},
	 { "VerseKey_getTestamentMax", _wrap_VerseKey_getTestamentMax, METH_O, NULL},
	 { "VerseKey_getBook", _wrap_VerseKey_getBook, METH_O, NULL},
	 { "VerseKey_getBookMax", _wrap_VerseKey_getBookMax, METH_O, NULL},
	 { "VerseKey_getChapter", _wrap_VerseKey_getChapter, METH_O, NULL},
	 { "VerseKey_getChapterMax", _wrap_VerseKey_getChapterMax, METH_O, NULL},
	 { "VerseKey_getVerse", _wrap_VerseKey_getVerse, METH_O, NULL},
	 { "VerseKey_getVerseMax", _wrap_VerseKey_getVerseMax, METH_O, NULL},
	 { "VerseKey_getSuffix", _wrap_VerseKey_getSuffix, METH_O, NULL},
	 { "VerseKey_setTestament", _wrap_VerseKey_setTestament, METH_VARARGS, NULL},
	 { "VerseKey_setBook", _wrap_VerseKey_setBook, METH_VARARGS, NULL},
	 { "VerseKey_setChapter", _wrap_VerseKey_setChapter, METH_VARARGS, NULL},
	 { "VerseKey_setVerse", _wrap_VerseKey_setVerse, METH_VARARGS, NULL},
	 { "VerseKey_setSuffix", _wrap_VerseKey_setSuffix, METH_VARARGS, NULL},
	 { "VerseKey_normalize", _wrap_VerseKey_normalize, METH_VARARGS, NULL},
	 { "VerseKey_setAutoNormalize", _wrap_VerseKey_setAutoNormalize, METH_VARARGS, NULL},
	 { "VerseKey_isAutoNormalize", _wrap_VerseKey_isAutoNormalize, METH_O, NULL},
	 { "VerseKey_setIntros", _wrap_VerseKey_setIntros, METH_VARARGS, NULL},
	 { "VerseKey_isIntros", _wrap_VerseKey_isIntros, METH_O, NULL},
	 { "VerseKey_getIndex", _wrap_VerseKey_getIndex, METH_O, NULL},
	 { "VerseKey_setIndex", _wrap_VerseKey_setIndex, METH_VARARGS, NULL},
	 { "VerseKey_getTestamentIndex", _wrap_VerseKey_getTestamentIndex, METH_O, NULL},
	 { "VerseKey_getOSISRef", _wrap_VerseKey_getOSISRef, METH_O, NULL},
	 { "VerseKey_convertToOSIS", _wrap_VerseKey_convertToOSIS, METH_VARARGS, NULL},
	 { "VerseKey_parseVerseList", _wrap_VerseKey_parseVerseList, METH_VARARGS, NULL},
	 { "VerseKey_getRangeText", _wrap_VerseKey_getRangeText, METH_O, NULL},
	 { "VerseKey_getShortRangeText", _wrap_VerseKey_getShortRangeText, METH_O, NULL},
	 { "VerseKey_getOSISRefRangeText", _wrap_VerseKey_getOSISRefRangeText, METH_O, NULL},
	 { "VerseKey_compare", _wrap_VerseKey_compare, METH_VARARGS, NULL},
	 { "VerseKey__compare", _wrap_VerseKey__compare, METH_VARARGS, NULL},
	 { "VerseKey_setVersificationSystem", _wrap_VerseKey_setVersificationSystem, METH_VARARGS, NULL},
	 { "VerseKey_getVersificationSystem", _wrap_VerseKey_getVersificationSystem, METH_O, NULL},
	 { "VerseKey_validateCurrentLocale", _wrap_VerseKey_validateCurrentLocale, METH_O, NULL},
	 { "VerseKey___eq__", _wrap_VerseKey___eq__, METH_VARARGS, NULL},
	 { "VerseKey___ne__", _wrap_VerseKey___ne__, METH_VARARGS, NULL},
	 { "VerseKey___gt__", _wrap_VerseKey___gt__, METH_VARARGS, NULL},
	 { "VerseKey___lt__", _wrap_VerseKey___lt__, METH_VARARGS, NULL},
	 { "VerseKey___ge__", _wrap_VerseKey___ge__, METH_VARARGS, NULL},
	 { "VerseKey___le__", _wrap_VerseKey___le__, METH_VARARGS, NULL},
	 { "VerseKey___isub__", _wrap_VerseKey___isub__, METH_VARARGS, NULL},
	 { "VerseKey___iadd__", _wrap_VerseKey___iadd__, METH_VARARGS, NULL},
	 { "VerseKey_castTo", _wrap_VerseKey_castTo, METH_O, NULL},
	 { "VerseKey_bookCount", _wrap_VerseKey_bookCount, METH_VARARGS, NULL},
	 { "VerseKey_getBookCount", _wrap_VerseKey_getBookCount, METH_O, NULL},
	 { "VerseKey_bookName", _wrap_VerseKey_bookName, METH_VARARGS, NULL},
	 { "VerseKey_getBookNumberByOSISName", _wrap_VerseKey_getBookNumberByOSISName, METH_VARARGS, NULL},
	 { "VerseKey_getOSISBookName", _wrap_VerseKey_getOSISBookName, METH_VARARGS, NULL},
	 { "VerseKey_chapterCount", _wrap_VerseKey_chapterCount, METH_VARARGS, NULL},
	 { "VerseKey_verseCount", _wrap_VerseKey_verseCount, METH_VARARGS, NULL},
	 { "VerseKey_swigregister", VerseKey_swigregister, METH_O, NULL},
	 { "VerseKey_swiginit", VerseKey_swiginit, METH_VARARGS, NULL},
	 { "abbrev_ab_get", _wrap_abbrev_ab_get, METH_O, NULL},
	 { "abbrev_osis_set", _wrap_abbrev_osis_set, METH_VARARGS, NULL},
	 { "abbrev_osis_get", _wrap_abbrev_osis_get, METH_O, NULL},
	 { "abbrev_getAbbrevCount", _wrap_abbrev_getAbbrevCount, METH_O, NULL},
	 { "abbrev_getAbbrevData", _wrap_abbrev_getAbbrevData, METH_VARARGS, NULL},
	 { "new_abbrev", _wrap_new_abbrev, METH_NOARGS, NULL},
	 { "delete_abbrev", _wrap_delete_abbrev, METH_O, NULL},
	 { "abbrev_swigregister", abbrev_swigregister, METH_O, NULL},
	 { "abbrev_swiginit", abbrev_swiginit, METH_VARARGS, NULL},
	 { "sbook_name_get", _wrap_sbook_name_get, METH_O, NULL},
	 { "sbook_osis_set", _wrap_sbook_osis_set, METH_VARARGS, NULL},
	 { "sbook_osis_get", _wrap_sbook_osis_get, METH_O, NULL},
	 { "sbook_prefAbbrev_get", _wrap_sbook_prefAbbrev_get, METH_O, NULL},
	 { "sbook_chapmax_set", _wrap_sbook_chapmax_set, METH_VARARGS, NULL},
	 { "sbook_chapmax_get", _wrap_sbook_chapmax_get, METH_O, NULL},
	 { "sbook_verseMax", _wrap_sbook_verseMax, METH_VARARGS, NULL},
	 { "new_sbook", _wrap_new_sbook, METH_NOARGS, NULL},
	 { "delete_sbook", _wrap_delete_sbook, METH_O, NULL},
	 { "sbook_swigregister", sbook_swigregister, METH_O, NULL},
	 { "sbook_swiginit", sbook_swiginit, METH_VARARGS, NULL},
	 { "new_VersificationMgr", _wrap_new_VersificationMgr, METH_NOARGS, NULL},
	 { "delete_VersificationMgr", _wrap_delete_VersificationMgr, METH_O, NULL},
	 { "VersificationMgr_getSystemVersificationMgr", _wrap_VersificationMgr_getSystemVersificationMgr, METH_NOARGS, NULL},
	 { "VersificationMgr_setSystemVersificationMgr", _wrap_VersificationMgr_setSystemVersificationMgr, METH_O, NULL},
	 { "VersificationMgr_getVersificationSystems", _wrap_VersificationMgr_getVersificationSystems, METH_O, NULL},
	 { "VersificationMgr_getVersificationSystem", _wrap_VersificationMgr_getVersificationSystem, METH_VARARGS, NULL},
	 { "VersificationMgr_registerVersificationSystem", _wrap_VersificationMgr_registerVersificationSystem, METH_VARARGS, NULL},
	 { "VersificationMgr_swigregister", VersificationMgr_swigregister, METH_O, NULL},
	 { "VersificationMgr_swiginit", VersificationMgr_swiginit, METH_VARARGS, NULL},
	 { "TreeKey_posChangeListener_set", _wrap_TreeKey_posChangeListener_set, METH_VARARGS, NULL},
	 { "TreeKey_posChangeListener_get", _wrap_TreeKey_posChangeListener_get, METH_O, NULL},
	 { "TreeKey_setPositionChangeListener", _wrap_TreeKey_setPositionChangeListener, METH_VARARGS, NULL},
	 { "delete_TreeKey", _wrap_delete_TreeKey, METH_O, NULL},
	 { "TreeKey_getLocalName", _wrap_TreeKey_getLocalName, METH_O, NULL},
	 { "TreeKey_setLocalName", _wrap_TreeKey_setLocalName, METH_VARARGS, NULL},
	 { "TreeKey_getLevel", _wrap_TreeKey_getLevel, METH_O, NULL},
	 { "TreeKey_getUserData", _wrap_TreeKey_getUserData, METH_VARARGS, NULL},
	 { "TreeKey_setUserData", _wrap_TreeKey_setUserData, METH_VARARGS, NULL},
	 { "TreeKey_root", _wrap_TreeKey_root, METH_O, NULL},
	 { "TreeKey_parent", _wrap_TreeKey_parent, METH_O, NULL},
	 { "TreeKey_firstChild", _wrap_TreeKey_firstChild, METH_O, NULL},
	 { "TreeKey_nextSibling", _wrap_TreeKey_nextSibling, METH_O, NULL},
	 { "TreeKey_previousSibling", _wrap_TreeKey_previousSibling, METH_O, NULL},
	 { "TreeKey_hasChildren", _wrap_TreeKey_hasChildren, METH_O, NULL},
	 { "TreeKey_append", _wrap_TreeKey_append, METH_O, NULL},
	 { "TreeKey_appendChild", _wrap_TreeKey_appendChild, METH_O, NULL},
	 { "TreeKey_insertBefore", _wrap_TreeKey_insertBefore, METH_O, NULL},
	 { "TreeKey_remove", _wrap_TreeKey_remove, METH_O, NULL},
	 { "TreeKey_setOffset", _wrap_TreeKey_setOffset, METH_VARARGS, NULL},
	 { "TreeKey_getOffset", _wrap_TreeKey_getOffset, METH_O, NULL},
	 { "TreeKey_setText", _wrap_TreeKey_setText, METH_VARARGS, NULL},
	 { "TreeKey_setPosition", _wrap_TreeKey_setPosition, METH_VARARGS, NULL},
	 { "TreeKey_getText", _wrap_TreeKey_getText, METH_O, NULL},
	 { "TreeKey_compare", _wrap_TreeKey_compare, METH_VARARGS, NULL},
	 { "TreeKey_decrement", _wrap_TreeKey_decrement, METH_VARARGS, NULL},
	 { "TreeKey_increment", _wrap_TreeKey_increment, METH_VARARGS, NULL},
	 { "TreeKey_isTraversable", _wrap_TreeKey_isTraversable, METH_O, NULL},
	 { "TreeKey_getIndex", _wrap_TreeKey_getIndex, METH_O, NULL},
	 { "TreeKey_setIndex", _wrap_TreeKey_setIndex, METH_VARARGS, NULL},
	 { "TreeKey_assureKeyPath", _wrap_TreeKey_assureKeyPath, METH_VARARGS, NULL},
	 { "TreeKey_save", _wrap_TreeKey_save, METH_O, NULL},
	 { "TreeKey___eq__", _wrap_TreeKey___eq__, METH_VARARGS, NULL},
	 { "TreeKey___ne__", _wrap_TreeKey___ne__, METH_VARARGS, NULL},
	 { "TreeKey___gt__", _wrap_TreeKey___gt__, METH_VARARGS, NULL},
	 { "TreeKey___lt__", _wrap_TreeKey___lt__, METH_VARARGS, NULL},
	 { "TreeKey___ge__", _wrap_TreeKey___ge__, METH_VARARGS, NULL},
	 { "TreeKey___le__", _wrap_TreeKey___le__, METH_VARARGS, NULL},
	 { "TreeKey___isub__", _wrap_TreeKey___isub__, METH_VARARGS, NULL},
	 { "TreeKey___iadd__", _wrap_TreeKey___iadd__, METH_VARARGS, NULL},
	 { "TreeKey_castTo", _wrap_TreeKey_castTo, METH_O, NULL},
	 { "TreeKey_swigregister", TreeKey_swigregister, METH_O, NULL},
	 { "new_TreeKeyIdx", _wrap_new_TreeKeyIdx, METH_VARARGS, NULL},
	 { "delete_TreeKeyIdx", _wrap_delete_TreeKeyIdx, METH_O, NULL},
	 { "TreeKeyIdx_clone", _wrap_TreeKeyIdx_clone, METH_O, NULL},
	 { "TreeKeyIdx_getLocalName", _wrap_TreeKeyIdx_getLocalName, METH_O, NULL},
	 { "TreeKeyIdx_setLocalName", _wrap_TreeKeyIdx_setLocalName, METH_VARARGS, NULL},
	 { "TreeKeyIdx_getUserData", _wrap_TreeKeyIdx_getUserData, METH_VARARGS, NULL},
	 { "TreeKeyIdx_setUserData", _wrap_TreeKeyIdx_setUserData, METH_VARARGS, NULL},
	 { "TreeKeyIdx_root", _wrap_TreeKeyIdx_root, METH_O, NULL},
	 { "TreeKeyIdx_parent", _wrap_TreeKeyIdx_parent, METH_O, NULL},
	 { "TreeKeyIdx_firstChild", _wrap_TreeKeyIdx_firstChild, METH_O, NULL},
	 { "TreeKeyIdx_nextSibling", _wrap_TreeKeyIdx_nextSibling, METH_O, NULL},
	 { "TreeKeyIdx_previousSibling", _wrap_TreeKeyIdx_previousSibling, METH_O, NULL},
	 { "TreeKeyIdx_hasChildren", _wrap_TreeKeyIdx_hasChildren, METH_O, NULL},
	 { "TreeKeyIdx_append", _wrap_TreeKeyIdx_append, METH_O, NULL},
	 { "TreeKeyIdx_appendChild", _wrap_TreeKeyIdx_appendChild, METH_O, NULL},
	 { "TreeKeyIdx_insertBefore", _wrap_TreeKeyIdx_insertBefore, METH_O, NULL},
	 { "TreeKeyIdx_remove", _wrap_TreeKeyIdx_remove, METH_O, NULL},
	 { "TreeKeyIdx_save", _wrap_TreeKeyIdx_save, METH_O, NULL},
	 { "TreeKeyIdx_copyFrom", _wrap_TreeKeyIdx_copyFrom, METH_VARARGS, NULL},
	 { "TreeKeyIdx_setOffset", _wrap_TreeKeyIdx_setOffset, METH_VARARGS, NULL},
	 { "TreeKeyIdx_getOffset", _wrap_TreeKeyIdx_getOffset, METH_O, NULL},
	 { "TreeKeyIdx_getLevel", _wrap_TreeKeyIdx_getLevel, METH_O, NULL},
	 { "TreeKeyIdx___eq__", _wrap_TreeKeyIdx___eq__, METH_VARARGS, NULL},
	 { "TreeKeyIdx___ne__", _wrap_TreeKeyIdx___ne__, METH_VARARGS, NULL},
	 { "TreeKeyIdx___gt__", _wrap_TreeKeyIdx___gt__, METH_VARARGS, NULL},
	 { "TreeKeyIdx___lt__", _wrap_TreeKeyIdx___lt__, METH_VARARGS, NULL},
	 { "TreeKeyIdx___ge__", _wrap_TreeKeyIdx___ge__, METH_VARARGS, NULL},
	 { "TreeKeyIdx___le__", _wrap_TreeKeyIdx___le__, METH_VARARGS, NULL},
	 { "TreeKeyIdx___isub__", _wrap_TreeKeyIdx___isub__, METH_VARARGS, NULL},
	 { "TreeKeyIdx___iadd__", _wrap_TreeKeyIdx___iadd__, METH_VARARGS, NULL},
	 { "TreeKeyIdx_setText", _wrap_TreeKeyIdx_setText, METH_VARARGS, NULL},
	 { "TreeKeyIdx_setPosition", _wrap_TreeKeyIdx_setPosition, METH_VARARGS, NULL},
	 { "TreeKeyIdx_getText", _wrap_TreeKeyIdx_getText, METH_O, NULL},
	 { "TreeKeyIdx__compare", _wrap_TreeKeyIdx__compare, METH_VARARGS, NULL},
	 { "TreeKeyIdx_compare", _wrap_TreeKeyIdx_compare, METH_VARARGS, NULL},
	 { "TreeKeyIdx_decrement", _wrap_TreeKeyIdx_decrement, METH_VARARGS, NULL},
	 { "TreeKeyIdx_increment", _wrap_TreeKeyIdx_increment, METH_VARARGS, NULL},
	 { "TreeKeyIdx_isTraversable", _wrap_TreeKeyIdx_isTraversable, METH_O, NULL},
	 { "TreeKeyIdx_create", _wrap_TreeKeyIdx_create, METH_O, NULL},
	 { "TreeKeyIdx_castTo", _wrap_TreeKeyIdx_castTo, METH_O, NULL},
	 { "TreeKeyIdx_swigregister", TreeKeyIdx_swigregister, METH_O, NULL},
	 { "TreeKeyIdx_swiginit", TreeKeyIdx_swiginit, METH_VARARGS, NULL},
	 { "new_VerseTreeKey", _wrap_new_VerseTreeKey, METH_VARARGS, NULL},
	 { "delete_VerseTreeKey", _wrap_delete_VerseTreeKey, METH_O, NULL},
	 { "VerseTreeKey_clone", _wrap_VerseTreeKey_clone, METH_O, NULL},
	 { "VerseTreeKey_isTraversable", _wrap_VerseTreeKey_isTraversable, METH_O, NULL},
	 { "VerseTreeKey_getTreeKey", _wrap_VerseTreeKey_getTreeKey, METH_VARARGS, NULL},
	 { "VerseTreeKey_positionChanged", _wrap_VerseTreeKey_positionChanged, METH_O, NULL},
	 { "VerseTreeKey_internalPosChange_set", _wrap_VerseTreeKey_internalPosChange_set, METH_VARARGS, NULL},
	 { "VerseTreeKey_internalPosChange_get", _wrap_VerseTreeKey_internalPosChange_get, METH_O, NULL},
	 { "VerseTreeKey_decrement", _wrap_VerseTreeKey_decrement, METH_VARARGS, NULL},
	 { "VerseTreeKey_increment", _wrap_VerseTreeKey_increment, METH_VARARGS, NULL},
	 { "VerseTreeKey_setPosition", _wrap_VerseTreeKey_setPosition, METH_VARARGS, NULL},
	 { "VerseTreeKey_newIndex", _wrap_VerseTreeKey_newIndex, METH_O, NULL},
	 { "VerseTreeKey___eq__", _wrap_VerseTreeKey___eq__, METH_VARARGS, NULL},
	 { "VerseTreeKey___ne__", _wrap_VerseTreeKey___ne__, METH_VARARGS, NULL},
	 { "VerseTreeKey___gt__", _wrap_VerseTreeKey___gt__, METH_VARARGS, NULL},
	 { "VerseTreeKey___lt__", _wrap_VerseTreeKey___lt__, METH_VARARGS, NULL},
	 { "VerseTreeKey___ge__", _wrap_VerseTreeKey___ge__, METH_VARARGS, NULL},
	 { "VerseTreeKey___le__", _wrap_VerseTreeKey___le__, METH_VARARGS, NULL},
	 { "VerseTreeKey___isub__", _wrap_VerseTreeKey___isub__, METH_VARARGS, NULL},
	 { "VerseTreeKey___iadd__", _wrap_VerseTreeKey___iadd__, METH_VARARGS, NULL},
	 { "VerseTreeKey_castTo", _wrap_VerseTreeKey_castTo, METH_O, NULL},
	 { "VerseTreeKey_swigregister", VerseTreeKey_swigregister, METH_O, NULL},
	 { "VerseTreeKey_swiginit", VerseTreeKey_swiginit, METH_VARARGS, NULL},
	 { "delete_SWDisplay", _wrap_delete_SWDisplay, METH_O, NULL},
	 { "SWDisplay_display", _wrap_SWDisplay_display, METH_VARARGS, NULL},
	 { "SWDisplay_swigregister", SWDisplay_swigregister, METH_O, NULL},
	 { "delete_SWFilter", _wrap_delete_SWFilter, METH_O, NULL},
	 { "SWFilter_processText", _wrap_SWFilter_processText, METH_VARARGS, NULL},
	 { "SWFilter_getHeader", _wrap_SWFilter_getHeader, METH_O, NULL},
	 { "SWFilter_swigregister", SWFilter_swigregister, METH_O, NULL},
	 { "delete_SWOptionFilter", _wrap_delete_SWOptionFilter, METH_O, NULL},
	 { "SWOptionFilter_isBoolean", _wrap_SWOptionFilter_isBoolean, METH_O, NULL},
	 { "SWOptionFilter_getOptionName", _wrap_SWOptionFilter_getOptionName, METH_O, NULL},
	 { "SWOptionFilter_getOptionTip", _wrap_SWOptionFilter_getOptionTip, METH_O, NULL},
	 { "SWOptionFilter_getOptionValue", _wrap_SWOptionFilter_getOptionValue, METH_O, NULL},
	 { "SWOptionFilter_setOptionValue", _wrap_SWOptionFilter_setOptionValue, METH_VARARGS, NULL},
	 { "SWOptionFilter_castTo", _wrap_SWOptionFilter_castTo, METH_O, NULL},
	 { "SWOptionFilter_swigregister", SWOptionFilter_swigregister, METH_O, NULL},
	 { "new_SWFilterMgr", _wrap_new_SWFilterMgr, METH_NOARGS, NULL},
	 { "delete_SWFilterMgr", _wrap_delete_SWFilterMgr, METH_O, NULL},
	 { "SWFilterMgr_setParentMgr", _wrap_SWFilterMgr_setParentMgr, METH_VARARGS, NULL},
	 { "SWFilterMgr_getParentMgr", _wrap_SWFilterMgr_getParentMgr, METH_O, NULL},
	 { "SWFilterMgr_addGlobalOptions", _wrap_SWFilterMgr_addGlobalOptions, METH_VARARGS, NULL},
	 { "SWFilterMgr_addLocalOptions", _wrap_SWFilterMgr_addLocalOptions, METH_VARARGS, NULL},
	 { "SWFilterMgr_addEncodingFilters", _wrap_SWFilterMgr_addEncodingFilters, METH_VARARGS, NULL},
	 { "SWFilterMgr_addRenderFilters", _wrap_SWFilterMgr_addRenderFilters, METH_VARARGS, NULL},
	 { "SWFilterMgr_addStripFilters", _wrap_SWFilterMgr_addStripFilters, METH_VARARGS, NULL},
	 { "SWFilterMgr_addRawFilters", _wrap_SWFilterMgr_addRawFilters, METH_VARARGS, NULL},
	 { "SWFilterMgr_swigregister", SWFilterMgr_swigregister, METH_O, NULL},
	 { "SWFilterMgr_swiginit", SWFilterMgr_swiginit, METH_VARARGS, NULL},
	 { "StringMgr_setSystemStringMgr", _wrap_StringMgr_setSystemStringMgr, METH_O, NULL},
	 { "StringMgr_getSystemStringMgr", _wrap_StringMgr_getSystemStringMgr, METH_NOARGS, NULL},
	 { "StringMgr_hasUTF8Support", _wrap_StringMgr_hasUTF8Support, METH_NOARGS, NULL},
	 { "StringMgr_upperUTF8", _wrap_StringMgr_upperUTF8, METH_VARARGS, NULL},
	 { "StringMgr_lowerUTF8", _wrap_StringMgr_lowerUTF8, METH_VARARGS, NULL},
	 { "StringMgr_isUpper", _wrap_StringMgr_isUpper, METH_VARARGS, NULL},
	 { "StringMgr_isLower", _wrap_StringMgr_isLower, METH_VARARGS, NULL},
	 { "StringMgr_isDigit", _wrap_StringMgr_isDigit, METH_VARARGS, NULL},
	 { "StringMgr_isAlpha", _wrap_StringMgr_isAlpha, METH_VARARGS, NULL},
	 { "StringMgr_upperLatin1", _wrap_StringMgr_upperLatin1, METH_VARARGS, NULL},
	 { "StringMgr_swigregister", StringMgr_swigregister, METH_O, NULL},
	 { "toupperstr", _wrap_toupperstr, METH_VARARGS, NULL},
	 { "tolowerstr", _wrap_tolowerstr, METH_VARARGS, NULL},
	 { "toupperstr_utf8", _wrap_toupperstr_utf8, METH_VARARGS, NULL},
	 { "PyStringMgr_upperUTF8", _wrap_PyStringMgr_upperUTF8, METH_VARARGS, NULL},
	 { "PyStringMgr_getUpper", _wrap_PyStringMgr_getUpper, METH_VARARGS, NULL},
	 { "new_PyStringMgr", _wrap_new_PyStringMgr, METH_O, NULL},
	 { "delete_PyStringMgr", _wrap_delete_PyStringMgr, METH_O, NULL},
	 { "disown_PyStringMgr", _wrap_disown_PyStringMgr, METH_O, NULL},
	 { "PyStringMgr_supportsUnicode", _wrap_PyStringMgr_supportsUnicode, METH_O, NULL},
	 { "PyStringMgr_swigregister", PyStringMgr_swigregister, METH_O, NULL},
	 { "PyStringMgr_swiginit", PyStringMgr_swiginit, METH_VARARGS, NULL},
	 { "delete_SWSearchable", _wrap_delete_SWSearchable, METH_O, NULL},
	 { "SWSearchable_deleteSearchFramework", _wrap_SWSearchable_deleteSearchFramework, METH_O, NULL},
	 { "SWSearchable_hasSearchFramework", _wrap_SWSearchable_hasSearchFramework, METH_O, NULL},
	 { "SWSearchable_isSearchOptimallySupported", _wrap_SWSearchable_isSearchOptimallySupported, METH_VARARGS, NULL},
	 { "SWSearchable_isSearchSupported", _wrap_SWSearchable_isSearchSupported, METH_VARARGS, NULL},
	 { "SWSearchable_doSearch", _wrap_SWSearchable_doSearch, METH_VARARGS, NULL},
	 { "SWSearchable_swigregister", SWSearchable_swigregister, METH_O, NULL},
	 { "SWModule_terminateSearch_set", _wrap_SWModule_terminateSearch_set, METH_VARARGS, NULL},
	 { "SWModule_terminateSearch_get", _wrap_SWModule_terminateSearch_get, METH_O, NULL},
	 { "delete_SWModule", _wrap_delete_SWModule, METH_O, NULL},
	 { "SWModule_popError", _wrap_SWModule_popError, METH_O, NULL},
	 { "SWModule_isUnicode", _wrap_SWModule_isUnicode, METH_O, NULL},
	 { "SWModule_getConfigEntry", _wrap_SWModule_getConfigEntry, METH_VARARGS, NULL},
	 { "SWModule_getBibliography", _wrap_SWModule_getBibliography, METH_VARARGS, NULL},
	 { "SWModule_getEntrySize", _wrap_SWModule_getEntrySize, METH_O, NULL},
	 { "SWModule_setKey", _wrap_SWModule_setKey, METH_VARARGS, NULL},
	 { "SWModule_setKeyText", _wrap_SWModule_setKeyText, METH_VARARGS, NULL},
	 { "SWModule_getKey", _wrap_SWModule_getKey, METH_O, NULL},
	 { "SWModule_getKeyText", _wrap_SWModule_getKeyText, METH_O, NULL},
	 { "SWModule_getIndex", _wrap_SWModule_getIndex, METH_O, NULL},
	 { "SWModule_setIndex", _wrap_SWModule_setIndex, METH_VARARGS, NULL},
	 { "SWModule_display", _wrap_SWModule_display, METH_O, NULL},
	 { "SWModule_getDisplay", _wrap_SWModule_getDisplay, METH_O, NULL},
	 { "SWModule_setDisplay", _wrap_SWModule_setDisplay, METH_VARARGS, NULL},
	 { "SWModule_getName", _wrap_SWModule_getName, METH_O, NULL},
	 { "SWModule_getDescription", _wrap_SWModule_getDescription, METH_O, NULL},
	 { "SWModule_getType", _wrap_SWModule_getType, METH_O, NULL},
	 { "SWModule_setType", _wrap_SWModule_setType, METH_VARARGS, NULL},
	 { "SWModule_getDirection", _wrap_SWModule_getDirection, METH_O, NULL},
	 { "SWModule_getEncoding", _wrap_SWModule_getEncoding, METH_O, NULL},
	 { "SWModule_getMarkup", _wrap_SWModule_getMarkup, METH_O, NULL},
	 { "SWModule_getLanguage", _wrap_SWModule_getLanguage, METH_O, NULL},
	 { "SWModule_createKey", _wrap_SWModule_createKey, METH_O, NULL},
	 { "SWModule_getRawEntryBuf", _wrap_SWModule_getRawEntryBuf, METH_O, NULL},
	 { "SWModule_getRawEntry", _wrap_SWModule_getRawEntry, METH_O, NULL},
	 { "SWModule_isWritable", _wrap_SWModule_isWritable, METH_O, NULL},
	 { "SWModule_createModule", _wrap_SWModule_createModule, METH_O, NULL},
	 { "SWModule_setEntry", _wrap_SWModule_setEntry, METH_VARARGS, NULL},
	 { "SWModule_linkEntry", _wrap_SWModule_linkEntry, METH_VARARGS, NULL},
	 { "SWModule_deleteEntry", _wrap_SWModule_deleteEntry, METH_O, NULL},
	 { "SWModule_decrement", _wrap_SWModule_decrement, METH_VARARGS, NULL},
	 { "SWModule_increment", _wrap_SWModule_increment, METH_VARARGS, NULL},
	 { "SWModule_setPosition", _wrap_SWModule_setPosition, METH_VARARGS, NULL},
	 { "SWModule_addRenderFilter", _wrap_SWModule_addRenderFilter, METH_VARARGS, NULL},
	 { "SWModule_getRenderFilters", _wrap_SWModule_getRenderFilters, METH_O, NULL},
	 { "SWModule_removeRenderFilter", _wrap_SWModule_removeRenderFilter, METH_VARARGS, NULL},
	 { "SWModule_replaceRenderFilter", _wrap_SWModule_replaceRenderFilter, METH_VARARGS, NULL},
	 { "SWModule_renderFilter", _wrap_SWModule_renderFilter, METH_VARARGS, NULL},
	 { "SWModule_addEncodingFilter", _wrap_SWModule_addEncodingFilter, METH_VARARGS, NULL},
	 { "SWModule_removeEncodingFilter", _wrap_SWModule_removeEncodingFilter, METH_VARARGS, NULL},
	 { "SWModule_replaceEncodingFilter", _wrap_SWModule_replaceEncodingFilter, METH_VARARGS, NULL},
	 { "SWModule_encodingFilter", _wrap_SWModule_encodingFilter, METH_VARARGS, NULL},
	 { "SWModule_addStripFilter", _wrap_SWModule_addStripFilter, METH_VARARGS, NULL},
	 { "SWModule_addRawFilter", _wrap_SWModule_addRawFilter, METH_VARARGS, NULL},
	 { "SWModule_stripFilter", _wrap_SWModule_stripFilter, METH_VARARGS, NULL},
	 { "SWModule_rawFilter", _wrap_SWModule_rawFilter, METH_VARARGS, NULL},
	 { "SWModule_addOptionFilter", _wrap_SWModule_addOptionFilter, METH_VARARGS, NULL},
	 { "SWModule_getOptionFilters", _wrap_SWModule_getOptionFilters, METH_O, NULL},
	 { "SWModule_optionFilter", _wrap_SWModule_optionFilter, METH_VARARGS, NULL},
	 { "SWModule_getRenderHeader", _wrap_SWModule_getRenderHeader, METH_O, NULL},
	 { "SWModule_stripText", _wrap_SWModule_stripText, METH_VARARGS, NULL},
	 { "SWModule_renderText", _wrap_SWModule_renderText, METH_VARARGS, NULL},
	 { "SWModule_setSkipConsecutiveLinks", _wrap_SWModule_setSkipConsecutiveLinks, METH_VARARGS, NULL},
	 { "SWModule_isSkipConsecutiveLinks", _wrap_SWModule_isSkipConsecutiveLinks, METH_O, NULL},
	 { "SWModule_isLinked", _wrap_SWModule_isLinked, METH_VARARGS, NULL},
	 { "SWModule_hasEntry", _wrap_SWModule_hasEntry, METH_VARARGS, NULL},
	 { "SWModule_setProcessEntryAttributes", _wrap_SWModule_setProcessEntryAttributes, METH_VARARGS, NULL},
	 { "SWModule_isProcessEntryAttributes", _wrap_SWModule_isProcessEntryAttributes, METH_O, NULL},
	 { "SWModule_deleteSearchFramework", _wrap_SWModule_deleteSearchFramework, METH_O, NULL},
	 { "SWModule_hasSearchFramework", _wrap_SWModule_hasSearchFramework, METH_O, NULL},
	 { "SWModule___lshift__", _wrap_SWModule___lshift__, METH_VARARGS, NULL},
	 { "SWModule___isub__", _wrap_SWModule___isub__, METH_VARARGS, NULL},
	 { "SWModule___iadd__", _wrap_SWModule___iadd__, METH_VARARGS, NULL},
	 { "SWModule_castTo", _wrap_SWModule_castTo, METH_O, NULL},
	 { "SWModule_getEntryAttributesMap", _wrap_SWModule_getEntryAttributesMap, METH_O, NULL},
	 { "SWModule_getConfigMap", _wrap_SWModule_getConfigMap, METH_O, NULL},
	 { "SWModule_swigregister", SWModule_swigregister, METH_O, NULL},
	 { "SWMgr_MODTYPE_BIBLES_get", _wrap_SWMgr_MODTYPE_BIBLES_get, METH_VARARGS, NULL},
	 { "SWMgr_MODTYPE_BIBLES_set", _wrap_SWMgr_MODTYPE_BIBLES_set, METH_O, NULL},
	 { "SWMgr_MODTYPE_COMMENTARIES_get", _wrap_SWMgr_MODTYPE_COMMENTARIES_get, METH_VARARGS, NULL},
	 { "SWMgr_MODTYPE_COMMENTARIES_set", _wrap_SWMgr_MODTYPE_COMMENTARIES_set, METH_O, NULL},
	 { "SWMgr_MODTYPE_LEXDICTS_get", _wrap_SWMgr_MODTYPE_LEXDICTS_get, METH_VARARGS, NULL},
	 { "SWMgr_MODTYPE_LEXDICTS_set", _wrap_SWMgr_MODTYPE_LEXDICTS_set, METH_O, NULL},
	 { "SWMgr_MODTYPE_GENBOOKS_get", _wrap_SWMgr_MODTYPE_GENBOOKS_get, METH_VARARGS, NULL},
	 { "SWMgr_MODTYPE_GENBOOKS_set", _wrap_SWMgr_MODTYPE_GENBOOKS_set, METH_O, NULL},
	 { "SWMgr_MODTYPE_DAILYDEVOS_get", _wrap_SWMgr_MODTYPE_DAILYDEVOS_get, METH_VARARGS, NULL},
	 { "SWMgr_MODTYPE_DAILYDEVOS_set", _wrap_SWMgr_MODTYPE_DAILYDEVOS_set, METH_O, NULL},
	 { "SWMgr_isICU_get", _wrap_SWMgr_isICU_get, METH_VARARGS, NULL},
	 { "SWMgr_isICU_set", _wrap_SWMgr_isICU_set, METH_O, NULL},
	 { "SWMgr_globalConfPath_get", _wrap_SWMgr_globalConfPath_get, METH_VARARGS, NULL},
	 { "SWMgr_globalConfPath_set", _wrap_SWMgr_globalConfPath_set, METH_O, NULL},
	 { "SWMgr_config_set", _wrap_SWMgr_config_set, METH_VARARGS, NULL},
	 { "SWMgr_config_get", _wrap_SWMgr_config_get, METH_O, NULL},
	 { "SWMgr_sysConfig_set", _wrap_SWMgr_sysConfig_set, METH_VARARGS, NULL},
	 { "SWMgr_sysConfig_get", _wrap_SWMgr_sysConfig_get, METH_O, NULL},
	 { "SWMgr_prefixPath_set", _wrap_SWMgr_prefixPath_set, METH_VARARGS, NULL},
	 { "SWMgr_prefixPath_get", _wrap_SWMgr_prefixPath_get, METH_O, NULL},
	 { "SWMgr_configPath_set", _wrap_SWMgr_configPath_set, METH_VARARGS, NULL},
	 { "SWMgr_configPath_get", _wrap_SWMgr_configPath_get, METH_O, NULL},
	 { "SWMgr_getModules", _wrap_SWMgr_getModules, METH_VARARGS, NULL},
	 { "SWMgr_getUtilModules", _wrap_SWMgr_getUtilModules, METH_VARARGS, NULL},
	 { "SWMgr_getModule", _wrap_SWMgr_getModule, METH_VARARGS, NULL},
	 { "new_SWMgr", _wrap_new_SWMgr, METH_VARARGS, NULL},
	 { "delete_SWMgr", _wrap_delete_SWMgr, METH_O, NULL},
	 { "SWMgr_augmentModules", _wrap_SWMgr_augmentModules, METH_VARARGS, NULL},
	 { "SWMgr_deleteModule", _wrap_SWMgr_deleteModule, METH_VARARGS, NULL},
	 { "SWMgr_InstallScan", _wrap_SWMgr_InstallScan, METH_VARARGS, NULL},
	 { "SWMgr_load", _wrap_SWMgr_load, METH_O, NULL},
	 { "SWMgr_setGlobalOption", _wrap_SWMgr_setGlobalOption, METH_VARARGS, NULL},
	 { "SWMgr_getGlobalOption", _wrap_SWMgr_getGlobalOption, METH_VARARGS, NULL},
	 { "SWMgr_getGlobalOptionTip", _wrap_SWMgr_getGlobalOptionTip, METH_VARARGS, NULL},
	 { "SWMgr_getGlobalOptions", _wrap_SWMgr_getGlobalOptions, METH_O, NULL},
	 { "SWMgr_getGlobalOptionValues", _wrap_SWMgr_getGlobalOptionValues, METH_VARARGS, NULL},
	 { "SWMgr_filterText", _wrap_SWMgr_filterText, METH_VARARGS, NULL},
	 { "SWMgr_setCipherKey", _wrap_SWMgr_setCipherKey, METH_VARARGS, NULL},
	 { "SWMgr_getGlobalOptionsVector", _wrap_SWMgr_getGlobalOptionsVector, METH_O, NULL},
	 { "SWMgr_getGlobalOptionValuesVector", _wrap_SWMgr_getGlobalOptionValuesVector, METH_VARARGS, NULL},
	 { "SWMgr_getModuleAt", _wrap_SWMgr_getModuleAt, METH_VARARGS, NULL},
	 { "SWMgr_swigregister", SWMgr_swigregister, METH_O, NULL},
	 { "SWMgr_swiginit", SWMgr_swiginit, METH_VARARGS, NULL},
	 { "DirEntry_name_set", _wrap_DirEntry_name_set, METH_VARARGS, NULL},
	 { "DirEntry_name_get", _wrap_DirEntry_name_get, METH_O, NULL},
	 { "DirEntry_size_set", _wrap_DirEntry_size_set, METH_VARARGS, NULL},
	 { "DirEntry_size_get", _wrap_DirEntry_size_get, METH_O, NULL},
	 { "DirEntry_isDirectory_set", _wrap_DirEntry_isDirectory_set, METH_VARARGS, NULL},
	 { "DirEntry_isDirectory_get", _wrap_DirEntry_isDirectory_get, METH_O, NULL},
	 { "new_DirEntry", _wrap_new_DirEntry, METH_NOARGS, NULL},
	 { "delete_DirEntry", _wrap_delete_DirEntry, METH_O, NULL},
	 { "DirEntry_swigregister", DirEntry_swigregister, METH_O, NULL},
	 { "DirEntry_swiginit", DirEntry_swiginit, METH_VARARGS, NULL},
	 { "FileMgr_CREAT_get", _wrap_FileMgr_CREAT_get, METH_VARARGS, NULL},
	 { "FileMgr_CREAT_set", _wrap_FileMgr_CREAT_set, METH_O, NULL},
	 { "FileMgr_APPEND_get", _wrap_FileMgr_APPEND_get, METH_VARARGS, NULL},
	 { "FileMgr_APPEND_set", _wrap_FileMgr_APPEND_set, METH_O, NULL},
	 { "FileMgr_TRUNC_get", _wrap_FileMgr_TRUNC_get, METH_VARARGS, NULL},
	 { "FileMgr_TRUNC_set", _wrap_FileMgr_TRUNC_set, METH_O, NULL},
	 { "FileMgr_RDONLY_get", _wrap_FileMgr_RDONLY_get, METH_VARARGS, NULL},
	 { "FileMgr_RDONLY_set", _wrap_FileMgr_RDONLY_set, METH_O, NULL},
	 { "FileMgr_RDWR_get", _wrap_FileMgr_RDWR_get, METH_VARARGS, NULL},
	 { "FileMgr_RDWR_set", _wrap_FileMgr_RDWR_set, METH_O, NULL},
	 { "FileMgr_WRONLY_get", _wrap_FileMgr_WRONLY_get, METH_VARARGS, NULL},
	 { "FileMgr_WRONLY_set", _wrap_FileMgr_WRONLY_set, METH_O, NULL},
	 { "FileMgr_IREAD_get", _wrap_FileMgr_IREAD_get, METH_VARARGS, NULL},
	 { "FileMgr_IREAD_set", _wrap_FileMgr_IREAD_set, METH_O, NULL},
	 { "FileMgr_IWRITE_get", _wrap_FileMgr_IWRITE_get, METH_VARARGS, NULL},
	 { "FileMgr_IWRITE_set", _wrap_FileMgr_IWRITE_set, METH_O, NULL},
	 { "FileMgr_maxFiles_set", _wrap_FileMgr_maxFiles_set, METH_VARARGS, NULL},
	 { "FileMgr_maxFiles_get", _wrap_FileMgr_maxFiles_get, METH_O, NULL},
	 { "FileMgr_getSystemFileMgr", _wrap_FileMgr_getSystemFileMgr, METH_NOARGS, NULL},
	 { "FileMgr_setSystemFileMgr", _wrap_FileMgr_setSystemFileMgr, METH_O, NULL},
	 { "new_FileMgr", _wrap_new_FileMgr, METH_VARARGS, NULL},
	 { "delete_FileMgr", _wrap_delete_FileMgr, METH_O, NULL},
	 { "FileMgr_open", _wrap_FileMgr_open, METH_VARARGS, NULL},
	 { "FileMgr_close", _wrap_FileMgr_close, METH_VARARGS, NULL},
	 { "FileMgr_flush", _wrap_FileMgr_flush, METH_O, NULL},
	 { "FileMgr_resourceConsumption", _wrap_FileMgr_resourceConsumption, METH_O, NULL},
	 { "FileMgr_getEnvValue", _wrap_FileMgr_getEnvValue, METH_O, NULL},
	 { "FileMgr_hasAccess", _wrap_FileMgr_hasAccess, METH_VARARGS, NULL},
	 { "FileMgr_existsFile", _wrap_FileMgr_existsFile, METH_VARARGS, NULL},
	 { "FileMgr_existsDir", _wrap_FileMgr_existsDir, METH_VARARGS, NULL},
	 { "FileMgr_getDirList", _wrap_FileMgr_getDirList, METH_VARARGS, NULL},
	 { "FileMgr_trunc", _wrap_FileMgr_trunc, METH_VARARGS, NULL},
	 { "FileMgr_isDirectory", _wrap_FileMgr_isDirectory, METH_O, NULL},
	 { "FileMgr_getFileSize", _wrap_FileMgr_getFileSize, METH_O, NULL},
	 { "FileMgr_createParent", _wrap_FileMgr_createParent, METH_O, NULL},
	 { "FileMgr_createPathAndFile", _wrap_FileMgr_createPathAndFile, METH_O, NULL},
	 { "FileMgr_openFile", _wrap_FileMgr_openFile, METH_VARARGS, NULL},
	 { "FileMgr_openFileReadOnly", _wrap_FileMgr_openFileReadOnly, METH_O, NULL},
	 { "FileMgr_closeFile", _wrap_FileMgr_closeFile, METH_O, NULL},
	 { "FileMgr_write", _wrap_FileMgr_write, METH_VARARGS, NULL},
	 { "FileMgr_copyFile", _wrap_FileMgr_copyFile, METH_VARARGS, NULL},
	 { "FileMgr_copyDir", _wrap_FileMgr_copyDir, METH_VARARGS, NULL},
	 { "FileMgr_removeDir", _wrap_FileMgr_removeDir, METH_O, NULL},
	 { "FileMgr_removeFile", _wrap_FileMgr_removeFile, METH_O, NULL},
	 { "FileMgr_getLine", _wrap_FileMgr_getLine, METH_VARARGS, NULL},
	 { "FileMgr_getHomeDir", _wrap_FileMgr_getHomeDir, METH_O, NULL},
	 { "FileMgr_swigregister", FileMgr_swigregister, METH_O, NULL},
	 { "FileMgr_swiginit", FileMgr_swiginit, METH_VARARGS, NULL},
	 { "FileDesc_getFd", _wrap_FileDesc_getFd, METH_O, NULL},
	 { "FileDesc_seek", _wrap_FileDesc_seek, METH_VARARGS, NULL},
	 { "FileDesc_read", _wrap_FileDesc_read, METH_VARARGS, NULL},
	 { "FileDesc_write", _wrap_FileDesc_write, METH_VARARGS, NULL},
	 { "FileDesc_path_set", _wrap_FileDesc_path_set, METH_VARARGS, NULL},
	 { "FileDesc_path_get", _wrap_FileDesc_path_get, METH_O, NULL},
	 { "FileDesc_mode_set", _wrap_FileDesc_mode_set, METH_VARARGS, NULL},
	 { "FileDesc_mode_get", _wrap_FileDesc_mode_get, METH_O, NULL},
	 { "FileDesc_perms_set", _wrap_FileDesc_perms_set, METH_VARARGS, NULL},
	 { "FileDesc_perms_get", _wrap_FileDesc_perms_get, METH_O, NULL},
	 { "FileDesc_tryDowngrade_set", _wrap_FileDesc_tryDowngrade_set, METH_VARARGS, NULL},
	 { "FileDesc_tryDowngrade_get", _wrap_FileDesc_tryDowngrade_get, METH_O, NULL},
	 { "FileDesc_swigregister", FileDesc_swigregister, METH_O, NULL},
	 { "new_EncodingFilterMgr", _wrap_new_EncodingFilterMgr, METH_VARARGS, NULL},
	 { "delete_EncodingFilterMgr", _wrap_delete_EncodingFilterMgr, METH_O, NULL},
	 { "EncodingFilterMgr_Encoding", _wrap_EncodingFilterMgr_Encoding, METH_VARARGS, NULL},
	 { "EncodingFilterMgr_getEncoding", _wrap_EncodingFilterMgr_getEncoding, METH_O, NULL},
	 { "EncodingFilterMgr_setEncoding", _wrap_EncodingFilterMgr_setEncoding, METH_VARARGS, NULL},
	 { "EncodingFilterMgr_addRawFilters", _wrap_EncodingFilterMgr_addRawFilters, METH_VARARGS, NULL},
	 { "EncodingFilterMgr_addEncodingFilters", _wrap_EncodingFilterMgr_addEncodingFilters, METH_VARARGS, NULL},
	 { "EncodingFilterMgr_castTo", _wrap_EncodingFilterMgr_castTo, METH_O, NULL},
	 { "EncodingFilterMgr_swigregister", EncodingFilterMgr_swigregister, METH_O, NULL},
	 { "EncodingFilterMgr_swiginit", EncodingFilterMgr_swiginit, METH_VARARGS, NULL},
	 { "new_MarkupFilterMgr", _wrap_new_MarkupFilterMgr, METH_VARARGS, NULL},
	 { "delete_MarkupFilterMgr", _wrap_delete_MarkupFilterMgr, METH_O, NULL},
	 { "MarkupFilterMgr_Markup", _wrap_MarkupFilterMgr_Markup, METH_VARARGS, NULL},
	 { "MarkupFilterMgr_getMarkup", _wrap_MarkupFilterMgr_getMarkup, METH_O, NULL},
	 { "MarkupFilterMgr_setMarkup", _wrap_MarkupFilterMgr_setMarkup, METH_VARARGS, NULL},
	 { "MarkupFilterMgr_addRenderFilters", _wrap_MarkupFilterMgr_addRenderFilters, METH_VARARGS, NULL},
	 { "MarkupFilterMgr_castTo", _wrap_MarkupFilterMgr_castTo, METH_O, NULL},
	 { "MarkupFilterMgr_swigregister", MarkupFilterMgr_swigregister, METH_O, NULL},
	 { "MarkupFilterMgr_swiginit", MarkupFilterMgr_swiginit, METH_VARARGS, NULL},
	 { "new_SWLocale", _wrap_new_SWLocale, METH_O, NULL},
	 { "delete_SWLocale", _wrap_delete_SWLocale, METH_O, NULL},
	 { "SWLocale_getName", _wrap_SWLocale_getName, METH_O, NULL},
	 { "SWLocale_getDescription", _wrap_SWLocale_getDescription, METH_O, NULL},
	 { "SWLocale_getEncoding", _wrap_SWLocale_getEncoding, METH_O, NULL},
	 { "SWLocale_translate", _wrap_SWLocale_translate, METH_VARARGS, NULL},
	 { "SWLocale_augment", _wrap_SWLocale_augment, METH_VARARGS, NULL},
	 { "SWLocale_DEFAULT_LOCALE_NAME_get", _wrap_SWLocale_DEFAULT_LOCALE_NAME_get, METH_VARARGS, NULL},
	 { "SWLocale_DEFAULT_LOCALE_NAME_set", _wrap_SWLocale_DEFAULT_LOCALE_NAME_set, METH_O, NULL},
	 { "SWLocale_getBookAbbrevs", _wrap_SWLocale_getBookAbbrevs, METH_O, NULL},
	 { "SWLocale_swigregister", SWLocale_swigregister, METH_O, NULL},
	 { "SWLocale_swiginit", SWLocale_swiginit, METH_VARARGS, NULL},
	 { "new_SWCompress", _wrap_new_SWCompress, METH_NOARGS, NULL},
	 { "delete_SWCompress", _wrap_delete_SWCompress, METH_O, NULL},
	 { "SWCompress_setUncompressedBuf", _wrap_SWCompress_setUncompressedBuf, METH_VARARGS, NULL},
	 { "SWCompress_getUncompressedBuf", _wrap_SWCompress_getUncompressedBuf, METH_VARARGS, NULL},
	 { "SWCompress_setCompressedBuf", _wrap_SWCompress_setCompressedBuf, METH_VARARGS, NULL},
	 { "SWCompress_getCompressedBuf", _wrap_SWCompress_getCompressedBuf, METH_VARARGS, NULL},
	 { "SWCompress_getChars", _wrap_SWCompress_getChars, METH_VARARGS, NULL},
	 { "SWCompress_sendChars", _wrap_SWCompress_sendChars, METH_VARARGS, NULL},
	 { "SWCompress_encode", _wrap_SWCompress_encode, METH_O, NULL},
	 { "SWCompress_decode", _wrap_SWCompress_decode, METH_O, NULL},
	 { "SWCompress_setLevel", _wrap_SWCompress_setLevel, METH_VARARGS, NULL},
	 { "SWCompress_getLevel", _wrap_SWCompress_getLevel, METH_O, NULL},
	 { "SWCompress_swigregister", SWCompress_swigregister, METH_O, NULL},
	 { "SWCompress_swiginit", SWCompress_swiginit, METH_VARARGS, NULL},
	 { "new_LZSSCompress", _wrap_new_LZSSCompress, METH_NOARGS, NULL},
	 { "delete_LZSSCompress", _wrap_delete_LZSSCompress, METH_O, NULL},
	 { "LZSSCompress_encode", _wrap_LZSSCompress_encode, METH_O, NULL},
	 { "LZSSCompress_decode", _wrap_LZSSCompress_decode, METH_O, NULL},
	 { "LZSSCompress_castTo", _wrap_LZSSCompress_castTo, METH_O, NULL},
	 { "LZSSCompress_swigregister", LZSSCompress_swigregister, METH_O, NULL},
	 { "LZSSCompress_swiginit", LZSSCompress_swiginit, METH_VARARGS, NULL},
	 { "new_ZipCompress", _wrap_new_ZipCompress, METH_NOARGS, NULL},
	 { "delete_ZipCompress", _wrap_delete_ZipCompress, METH_O, NULL},
	 { "ZipCompress_encode", _wrap_ZipCompress_encode, METH_O, NULL},
	 { "ZipCompress_decode", _wrap_ZipCompress_decode, METH_O, NULL},
	 { "ZipCompress_unTarGZ", _wrap_ZipCompress_unTarGZ, METH_VARARGS, NULL},
	 { "ZipCompress_castTo", _wrap_ZipCompress_castTo, METH_O, NULL},
	 { "ZipCompress_swigregister", ZipCompress_swigregister, METH_O, NULL},
	 { "ZipCompress_swiginit", ZipCompress_swiginit, METH_VARARGS, NULL},
	 { "delete_SWCom", _wrap_delete_SWCom, METH_O, NULL},
	 { "SWCom_createKey", _wrap_SWCom_createKey, METH_O, NULL},
	 { "SWCom_getIndex", _wrap_SWCom_getIndex, METH_O, NULL},
	 { "SWCom_setIndex", _wrap_SWCom_setIndex, METH_VARARGS, NULL},
	 { "SWCom___lshift__", _wrap_SWCom___lshift__, METH_VARARGS, NULL},
	 { "SWCom___isub__", _wrap_SWCom___isub__, METH_VARARGS, NULL},
	 { "SWCom___iadd__", _wrap_SWCom___iadd__, METH_VARARGS, NULL},
	 { "SWCom_castTo", _wrap_SWCom_castTo, METH_O, NULL},
	 { "SWCom_swigregister", SWCom_swigregister, METH_O, NULL},
	 { "new_RawCom", _wrap_new_RawCom, METH_VARARGS, NULL},
	 { "delete_RawCom", _wrap_delete_RawCom, METH_O, NULL},
	 { "RawCom_getRawEntryBuf", _wrap_RawCom_getRawEntryBuf, METH_O, NULL},
	 { "RawCom_increment", _wrap_RawCom_increment, METH_VARARGS, NULL},
	 { "RawCom_decrement", _wrap_RawCom_decrement, METH_VARARGS, NULL},
	 { "RawCom_isWritable", _wrap_RawCom_isWritable, METH_O, NULL},
	 { "RawCom_createModule", _wrap_RawCom_createModule, METH_VARARGS, NULL},
	 { "RawCom_setEntry", _wrap_RawCom_setEntry, METH_VARARGS, NULL},
	 { "RawCom_linkEntry", _wrap_RawCom_linkEntry, METH_VARARGS, NULL},
	 { "RawCom_deleteEntry", _wrap_RawCom_deleteEntry, METH_O, NULL},
	 { "RawCom_isLinked", _wrap_RawCom_isLinked, METH_VARARGS, NULL},
	 { "RawCom_hasEntry", _wrap_RawCom_hasEntry, METH_VARARGS, NULL},
	 { "RawCom___lshift__", _wrap_RawCom___lshift__, METH_VARARGS, NULL},
	 { "RawCom___isub__", _wrap_RawCom___isub__, METH_VARARGS, NULL},
	 { "RawCom___iadd__", _wrap_RawCom___iadd__, METH_VARARGS, NULL},
	 { "RawCom_castTo", _wrap_RawCom_castTo, METH_O, NULL},
	 { "RawCom_swigregister", RawCom_swigregister, METH_O, NULL},
	 { "RawCom_swiginit", RawCom_swiginit, METH_VARARGS, NULL},
	 { "new_zCom", _wrap_new_zCom, METH_VARARGS, NULL},
	 { "delete_zCom", _wrap_delete_zCom, METH_O, NULL},
	 { "zCom_getRawEntryBuf", _wrap_zCom_getRawEntryBuf, METH_O, NULL},
	 { "zCom_increment", _wrap_zCom_increment, METH_VARARGS, NULL},
	 { "zCom_decrement", _wrap_zCom_decrement, METH_VARARGS, NULL},
	 { "zCom_isWritable", _wrap_zCom_isWritable, METH_O, NULL},
	 { "zCom_createModule", _wrap_zCom_createModule, METH_VARARGS, NULL},
	 { "zCom_setEntry", _wrap_zCom_setEntry, METH_VARARGS, NULL},
	 { "zCom_linkEntry", _wrap_zCom_linkEntry, METH_VARARGS, NULL},
	 { "zCom_deleteEntry", _wrap_zCom_deleteEntry, METH_O, NULL},
	 { "zCom_rawZFilter", _wrap_zCom_rawZFilter, METH_VARARGS, NULL},
	 { "zCom_flush", _wrap_zCom_flush, METH_O, NULL},
	 { "zCom_isLinked", _wrap_zCom_isLinked, METH_VARARGS, NULL},
	 { "zCom_hasEntry", _wrap_zCom_hasEntry, METH_VARARGS, NULL},
	 { "zCom___lshift__", _wrap_zCom___lshift__, METH_VARARGS, NULL},
	 { "zCom___isub__", _wrap_zCom___isub__, METH_VARARGS, NULL},
	 { "zCom___iadd__", _wrap_zCom___iadd__, METH_VARARGS, NULL},
	 { "zCom_castTo", _wrap_zCom_castTo, METH_O, NULL},
	 { "zCom_swigregister", zCom_swigregister, METH_O, NULL},
	 { "zCom_swiginit", zCom_swiginit, METH_VARARGS, NULL},
	 { "delete_SWGenBook", _wrap_delete_SWGenBook, METH_O, NULL},
	 { "SWGenBook_createKey", _wrap_SWGenBook_createKey, METH_O, NULL},
	 { "SWGenBook___lshift__", _wrap_SWGenBook___lshift__, METH_VARARGS, NULL},
	 { "SWGenBook___isub__", _wrap_SWGenBook___isub__, METH_VARARGS, NULL},
	 { "SWGenBook___iadd__", _wrap_SWGenBook___iadd__, METH_VARARGS, NULL},
	 { "SWGenBook_castTo", _wrap_SWGenBook_castTo, METH_O, NULL},
	 { "SWGenBook_swigregister", SWGenBook_swigregister, METH_O, NULL},
	 { "new_RawGenBook", _wrap_new_RawGenBook, METH_VARARGS, NULL},
	 { "delete_RawGenBook", _wrap_delete_RawGenBook, METH_O, NULL},
	 { "RawGenBook_getRawEntryBuf", _wrap_RawGenBook_getRawEntryBuf, METH_O, NULL},
	 { "RawGenBook_isWritable", _wrap_RawGenBook_isWritable, METH_O, NULL},
	 { "RawGenBook_createModule", _wrap_RawGenBook_createModule, METH_O, NULL},
	 { "RawGenBook_setEntry", _wrap_RawGenBook_setEntry, METH_VARARGS, NULL},
	 { "RawGenBook_linkEntry", _wrap_RawGenBook_linkEntry, METH_VARARGS, NULL},
	 { "RawGenBook_deleteEntry", _wrap_RawGenBook_deleteEntry, METH_O, NULL},
	 { "RawGenBook_createKey", _wrap_RawGenBook_createKey, METH_O, NULL},
	 { "RawGenBook_hasEntry", _wrap_RawGenBook_hasEntry, METH_VARARGS, NULL},
	 { "RawGenBook___lshift__", _wrap_RawGenBook___lshift__, METH_VARARGS, NULL},
	 { "RawGenBook___isub__", _wrap_RawGenBook___isub__, METH_VARARGS, NULL},
	 { "RawGenBook___iadd__", _wrap_RawGenBook___iadd__, METH_VARARGS, NULL},
	 { "RawGenBook_castTo", _wrap_RawGenBook_castTo, METH_O, NULL},
	 { "RawGenBook_swigregister", RawGenBook_swigregister, METH_O, NULL},
	 { "RawGenBook_swiginit", RawGenBook_swiginit, METH_VARARGS, NULL},
	 { "delete_SWLD", _wrap_delete_SWLD, METH_O, NULL},
	 { "SWLD_createKey", _wrap_SWLD_createKey, METH_O, NULL},
	 { "SWLD_getKeyText", _wrap_SWLD_getKeyText, METH_O, NULL},
	 { "SWLD_setPosition", _wrap_SWLD_setPosition, METH_VARARGS, NULL},
	 { "SWLD_getEntryCount", _wrap_SWLD_getEntryCount, METH_O, NULL},
	 { "SWLD_getEntryForKey", _wrap_SWLD_getEntryForKey, METH_VARARGS, NULL},
	 { "SWLD_getKeyForEntry", _wrap_SWLD_getKeyForEntry, METH_VARARGS, NULL},
	 { "SWLD_hasEntry", _wrap_SWLD_hasEntry, METH_VARARGS, NULL},
	 { "SWLD___lshift__", _wrap_SWLD___lshift__, METH_VARARGS, NULL},
	 { "SWLD___isub__", _wrap_SWLD___isub__, METH_VARARGS, NULL},
	 { "SWLD___iadd__", _wrap_SWLD___iadd__, METH_VARARGS, NULL},
	 { "SWLD_castTo", _wrap_SWLD_castTo, METH_O, NULL},
	 { "SWLD_swigregister", SWLD_swigregister, METH_O, NULL},
	 { "new_RawLD", _wrap_new_RawLD, METH_VARARGS, NULL},
	 { "delete_RawLD", _wrap_delete_RawLD, METH_O, NULL},
	 { "RawLD_getRawEntryBuf", _wrap_RawLD_getRawEntryBuf, METH_O, NULL},
	 { "RawLD_increment", _wrap_RawLD_increment, METH_VARARGS, NULL},
	 { "RawLD_decrement", _wrap_RawLD_decrement, METH_VARARGS, NULL},
	 { "RawLD_isWritable", _wrap_RawLD_isWritable, METH_O, NULL},
	 { "RawLD_createModule", _wrap_RawLD_createModule, METH_O, NULL},
	 { "RawLD_setEntry", _wrap_RawLD_setEntry, METH_VARARGS, NULL},
	 { "RawLD_linkEntry", _wrap_RawLD_linkEntry, METH_VARARGS, NULL},
	 { "RawLD_deleteEntry", _wrap_RawLD_deleteEntry, METH_O, NULL},
	 { "RawLD_getEntryCount", _wrap_RawLD_getEntryCount, METH_O, NULL},
	 { "RawLD_getEntryForKey", _wrap_RawLD_getEntryForKey, METH_VARARGS, NULL},
	 { "RawLD_getKeyForEntry", _wrap_RawLD_getKeyForEntry, METH_VARARGS, NULL},
	 { "RawLD___lshift__", _wrap_RawLD___lshift__, METH_VARARGS, NULL},
	 { "RawLD___isub__", _wrap_RawLD___isub__, METH_VARARGS, NULL},
	 { "RawLD___iadd__", _wrap_RawLD___iadd__, METH_VARARGS, NULL},
	 { "RawLD_castTo", _wrap_RawLD_castTo, METH_O, NULL},
	 { "RawLD_swigregister", RawLD_swigregister, METH_O, NULL},
	 { "RawLD_swiginit", RawLD_swiginit, METH_VARARGS, NULL},
	 { "new_RawLD4", _wrap_new_RawLD4, METH_VARARGS, NULL},
	 { "delete_RawLD4", _wrap_delete_RawLD4, METH_O, NULL},
	 { "RawLD4_getRawEntryBuf", _wrap_RawLD4_getRawEntryBuf, METH_O, NULL},
	 { "RawLD4_increment", _wrap_RawLD4_increment, METH_VARARGS, NULL},
	 { "RawLD4_decrement", _wrap_RawLD4_decrement, METH_VARARGS, NULL},
	 { "RawLD4_isWritable", _wrap_RawLD4_isWritable, METH_O, NULL},
	 { "RawLD4_createModule", _wrap_RawLD4_createModule, METH_O, NULL},
	 { "RawLD4_setEntry", _wrap_RawLD4_setEntry, METH_VARARGS, NULL},
	 { "RawLD4_linkEntry", _wrap_RawLD4_linkEntry, METH_VARARGS, NULL},
	 { "RawLD4_deleteEntry", _wrap_RawLD4_deleteEntry, METH_O, NULL},
	 { "RawLD4_getEntryCount", _wrap_RawLD4_getEntryCount, METH_O, NULL},
	 { "RawLD4_getEntryForKey", _wrap_RawLD4_getEntryForKey, METH_VARARGS, NULL},
	 { "RawLD4_getKeyForEntry", _wrap_RawLD4_getKeyForEntry, METH_VARARGS, NULL},
	 { "RawLD4___lshift__", _wrap_RawLD4___lshift__, METH_VARARGS, NULL},
	 { "RawLD4___isub__", _wrap_RawLD4___isub__, METH_VARARGS, NULL},
	 { "RawLD4___iadd__", _wrap_RawLD4___iadd__, METH_VARARGS, NULL},
	 { "RawLD4_castTo", _wrap_RawLD4_castTo, METH_O, NULL},
	 { "RawLD4_swigregister", RawLD4_swigregister, METH_O, NULL},
	 { "RawLD4_swiginit", RawLD4_swiginit, METH_VARARGS, NULL},
	 { "new_zLD", _wrap_new_zLD, METH_VARARGS, NULL},
	 { "delete_zLD", _wrap_delete_zLD, METH_O, NULL},
	 { "zLD_getRawEntryBuf", _wrap_zLD_getRawEntryBuf, METH_O, NULL},
	 { "zLD_increment", _wrap_zLD_increment, METH_VARARGS, NULL},
	 { "zLD_decrement", _wrap_zLD_decrement, METH_VARARGS, NULL},
	 { "zLD_isWritable", _wrap_zLD_isWritable, METH_O, NULL},
	 { "zLD_createModule", _wrap_zLD_createModule, METH_O, NULL},
	 { "zLD_setEntry", _wrap_zLD_setEntry, METH_VARARGS, NULL},
	 { "zLD_linkEntry", _wrap_zLD_linkEntry, METH_VARARGS, NULL},
	 { "zLD_deleteEntry", _wrap_zLD_deleteEntry, METH_O, NULL},
	 { "zLD_rawZFilter", _wrap_zLD_rawZFilter, METH_VARARGS, NULL},
	 { "zLD_flush", _wrap_zLD_flush, METH_O, NULL},
	 { "zLD_getEntryCount", _wrap_zLD_getEntryCount, METH_O, NULL},
	 { "zLD_getEntryForKey", _wrap_zLD_getEntryForKey, METH_VARARGS, NULL},
	 { "zLD_getKeyForEntry", _wrap_zLD_getKeyForEntry, METH_VARARGS, NULL},
	 { "zLD___lshift__", _wrap_zLD___lshift__, METH_VARARGS, NULL},
	 { "zLD___isub__", _wrap_zLD___isub__, METH_VARARGS, NULL},
	 { "zLD___iadd__", _wrap_zLD___iadd__, METH_VARARGS, NULL},
	 { "zLD_castTo", _wrap_zLD_castTo, METH_O, NULL},
	 { "zLD_swigregister", zLD_swigregister, METH_O, NULL},
	 { "zLD_swiginit", zLD_swiginit, METH_VARARGS, NULL},
	 { "delete_SWText", _wrap_delete_SWText, METH_O, NULL},
	 { "SWText_createKey", _wrap_SWText_createKey, METH_O, NULL},
	 { "SWText_getIndex", _wrap_SWText_getIndex, METH_O, NULL},
	 { "SWText_setIndex", _wrap_SWText_setIndex, METH_VARARGS, NULL},
	 { "SWText___lshift__", _wrap_SWText___lshift__, METH_VARARGS, NULL},
	 { "SWText___isub__", _wrap_SWText___isub__, METH_VARARGS, NULL},
	 { "SWText___iadd__", _wrap_SWText___iadd__, METH_VARARGS, NULL},
	 { "SWText_castTo", _wrap_SWText_castTo, METH_O, NULL},
	 { "SWText_swigregister", SWText_swigregister, METH_O, NULL},
	 { "new_RawText", _wrap_new_RawText, METH_VARARGS, NULL},
	 { "delete_RawText", _wrap_delete_RawText, METH_O, NULL},
	 { "RawText_getRawEntryBuf", _wrap_RawText_getRawEntryBuf, METH_O, NULL},
	 { "RawText_increment", _wrap_RawText_increment, METH_VARARGS, NULL},
	 { "RawText_decrement", _wrap_RawText_decrement, METH_VARARGS, NULL},
	 { "RawText_isWritable", _wrap_RawText_isWritable, METH_O, NULL},
	 { "RawText_createModule", _wrap_RawText_createModule, METH_VARARGS, NULL},
	 { "RawText_setEntry", _wrap_RawText_setEntry, METH_VARARGS, NULL},
	 { "RawText_linkEntry", _wrap_RawText_linkEntry, METH_VARARGS, NULL},
	 { "RawText_deleteEntry", _wrap_RawText_deleteEntry, METH_O, NULL},
	 { "RawText_isLinked", _wrap_RawText_isLinked, METH_VARARGS, NULL},
	 { "RawText_hasEntry", _wrap_RawText_hasEntry, METH_VARARGS, NULL},
	 { "RawText___lshift__", _wrap_RawText___lshift__, METH_VARARGS, NULL},
	 { "RawText___isub__", _wrap_RawText___isub__, METH_VARARGS, NULL},
	 { "RawText___iadd__", _wrap_RawText___iadd__, METH_VARARGS, NULL},
	 { "RawText_castTo", _wrap_RawText_castTo, METH_O, NULL},
	 { "RawText_swigregister", RawText_swigregister, METH_O, NULL},
	 { "RawText_swiginit", RawText_swiginit, METH_VARARGS, NULL},
	 { "new_zText", _wrap_new_zText, METH_VARARGS, NULL},
	 { "delete_zText", _wrap_delete_zText, METH_O, NULL},
	 { "zText_getRawEntryBuf", _wrap_zText_getRawEntryBuf, METH_O, NULL},
	 { "zText_increment", _wrap_zText_increment, METH_VARARGS, NULL},
	 { "zText_decrement", _wrap_zText_decrement, METH_VARARGS, NULL},
	 { "zText_isWritable", _wrap_zText_isWritable, METH_O, NULL},
	 { "zText_createModule", _wrap_zText_createModule, METH_VARARGS, NULL},
	 { "zText_setEntry", _wrap_zText_setEntry, METH_VARARGS, NULL},
	 { "zText_linkEntry", _wrap_zText_linkEntry, METH_VARARGS, NULL},
	 { "zText_deleteEntry", _wrap_zText_deleteEntry, METH_O, NULL},
	 { "zText_rawZFilter", _wrap_zText_rawZFilter, METH_VARARGS, NULL},
	 { "zText_flush", _wrap_zText_flush, METH_O, NULL},
	 { "zText_isLinked", _wrap_zText_isLinked, METH_VARARGS, NULL},
	 { "zText_hasEntry", _wrap_zText_hasEntry, METH_VARARGS, NULL},
	 { "zText___lshift__", _wrap_zText___lshift__, METH_VARARGS, NULL},
	 { "zText___isub__", _wrap_zText___isub__, METH_VARARGS, NULL},
	 { "zText___iadd__", _wrap_zText___iadd__, METH_VARARGS, NULL},
	 { "zText_castTo", _wrap_zText_castTo, METH_O, NULL},
	 { "zText_swigregister", zText_swigregister, METH_O, NULL},
	 { "zText_swiginit", zText_swiginit, METH_VARARGS, NULL},
	 { "new_LocaleMgr", _wrap_new_LocaleMgr, METH_VARARGS, NULL},
	 { "delete_LocaleMgr", _wrap_delete_LocaleMgr, METH_O, NULL},
	 { "LocaleMgr_getLocale", _wrap_LocaleMgr_getLocale, METH_VARARGS, NULL},
	 { "LocaleMgr_getAvailableLocales", _wrap_LocaleMgr_getAvailableLocales, METH_O, NULL},
	 { "LocaleMgr_translate", _wrap_LocaleMgr_translate, METH_VARARGS, NULL},
	 { "LocaleMgr_getDefaultLocaleName", _wrap_LocaleMgr_getDefaultLocaleName, METH_O, NULL},
	 { "LocaleMgr_setDefaultLocaleName", _wrap_LocaleMgr_setDefaultLocaleName, METH_VARARGS, NULL},
	 { "LocaleMgr_getSystemLocaleMgr", _wrap_LocaleMgr_getSystemLocaleMgr, METH_NOARGS, NULL},
	 { "LocaleMgr_setSystemLocaleMgr", _wrap_LocaleMgr_setSystemLocaleMgr, METH_O, NULL},
	 { "LocaleMgr_loadConfigDir", _wrap_LocaleMgr_loadConfigDir, METH_VARARGS, NULL},
	 { "LocaleMgr_getAvailableLocalesVector", _wrap_LocaleMgr_getAvailableLocalesVector, METH_O, NULL},
	 { "LocaleMgr_swigregister", LocaleMgr_swigregister, METH_O, NULL},
	 { "LocaleMgr_swiginit", LocaleMgr_swiginit, METH_VARARGS, NULL},
	 { "new_URL", _wrap_new_URL, METH_O, NULL},
	 { "URL_getProtocol", _wrap_URL_getProtocol, METH_O, NULL},
	 { "URL_getHostName", _wrap_URL_getHostName, METH_O, NULL},
	 { "URL_getPath", _wrap_URL_getPath, METH_O, NULL},
	 { "URL_getParameters", _wrap_URL_getParameters, METH_O, NULL},
	 { "URL_getParameterValue", _wrap_URL_getParameterValue, METH_VARARGS, NULL},
	 { "URL_encode", _wrap_URL_encode, METH_O, NULL},
	 { "URL_decode", _wrap_URL_decode, METH_O, NULL},
	 { "delete_URL", _wrap_delete_URL, METH_O, NULL},
	 { "URL_swigregister", URL_swigregister, METH_O, NULL},
	 { "URL_swiginit", URL_swiginit, METH_VARARGS, NULL},
	 { "new_XMLTag", _wrap_new_XMLTag, METH_VARARGS, NULL},
	 { "delete_XMLTag", _wrap_delete_XMLTag, METH_O, NULL},
	 { "XMLTag_setText", _wrap_XMLTag_setText, METH_VARARGS, NULL},
	 { "XMLTag_getName", _wrap_XMLTag_getName, METH_O, NULL},
	 { "XMLTag_isEmpty", _wrap_XMLTag_isEmpty, METH_O, NULL},
	 { "XMLTag_setEmpty", _wrap_XMLTag_setEmpty, METH_VARARGS, NULL},
	 { "XMLTag_isEndTag", _wrap_XMLTag_isEndTag, METH_VARARGS, NULL},
	 { "XMLTag_setEndTag", _wrap_XMLTag_setEndTag, METH_VARARGS, NULL},
	 { "XMLTag_getAttributeNames", _wrap_XMLTag_getAttributeNames, METH_O, NULL},
	 { "XMLTag_getAttributePartCount", _wrap_XMLTag_getAttributePartCount, METH_VARARGS, NULL},
	 { "XMLTag_getAttribute", _wrap_XMLTag_getAttribute, METH_VARARGS, NULL},
	 { "XMLTag_setAttribute", _wrap_XMLTag_setAttribute, METH_VARARGS, NULL},
	 { "XMLTag_toString", _wrap_XMLTag_toString, METH_O, NULL},
	 { "XMLTag_swigregister", XMLTag_swigregister, METH_O, NULL},
	 { "XMLTag_swiginit", XMLTag_swiginit, METH_VARARGS, NULL},
	 { "new_BasicFilterUserData", _wrap_new_BasicFilterUserData, METH_VARARGS, NULL},
	 { "delete_BasicFilterUserData", _wrap_delete_BasicFilterUserData, METH_O, NULL},
	 { "BasicFilterUserData_module_set", _wrap_BasicFilterUserData_module_set, METH_VARARGS, NULL},
	 { "BasicFilterUserData_module_get", _wrap_BasicFilterUserData_module_get, METH_O, NULL},
	 { "BasicFilterUserData_key_set", _wrap_BasicFilterUserData_key_set, METH_VARARGS, NULL},
	 { "BasicFilterUserData_key_get", _wrap_BasicFilterUserData_key_get, METH_O, NULL},
	 { "BasicFilterUserData_vkey_set", _wrap_BasicFilterUserData_vkey_set, METH_VARARGS, NULL},
	 { "BasicFilterUserData_vkey_get", _wrap_BasicFilterUserData_vkey_get, METH_O, NULL},
	 { "BasicFilterUserData_lastTextNode_set", _wrap_BasicFilterUserData_lastTextNode_set, METH_VARARGS, NULL},
	 { "BasicFilterUserData_lastTextNode_get", _wrap_BasicFilterUserData_lastTextNode_get, METH_O, NULL},
	 { "BasicFilterUserData_lastSuspendSegment_set", _wrap_BasicFilterUserData_lastSuspendSegment_set, METH_VARARGS, NULL},
	 { "BasicFilterUserData_lastSuspendSegment_get", _wrap_BasicFilterUserData_lastSuspendSegment_get, METH_O, NULL},
	 { "BasicFilterUserData_suspendTextPassThru_set", _wrap_BasicFilterUserData_suspendTextPassThru_set, METH_VARARGS, NULL},
	 { "BasicFilterUserData_suspendTextPassThru_get", _wrap_BasicFilterUserData_suspendTextPassThru_get, METH_O, NULL},
	 { "BasicFilterUserData_supressAdjacentWhitespace_set", _wrap_BasicFilterUserData_supressAdjacentWhitespace_set, METH_VARARGS, NULL},
	 { "BasicFilterUserData_supressAdjacentWhitespace_get", _wrap_BasicFilterUserData_supressAdjacentWhitespace_get, METH_O, NULL},
	 { "BasicFilterUserData_swigregister", BasicFilterUserData_swigregister, METH_O, NULL},
	 { "BasicFilterUserData_swiginit", BasicFilterUserData_swiginit, METH_VARARGS, NULL},
	 { "new_SWBasicFilter", _wrap_new_SWBasicFilter, METH_NOARGS, NULL},
	 { "SWBasicFilter_processText", _wrap_SWBasicFilter_processText, METH_VARARGS, NULL},
	 { "delete_SWBasicFilter", _wrap_delete_SWBasicFilter, METH_O, NULL},
	 { "SWBasicFilter_swigregister", SWBasicFilter_swigregister, METH_O, NULL},
	 { "SWBasicFilter_swiginit", SWBasicFilter_swiginit, METH_VARARGS, NULL},
	 { "new_OSISHTMLHREF", _wrap_new_OSISHTMLHREF, METH_NOARGS, NULL},
	 { "OSISHTMLHREF_setMorphFirst", _wrap_OSISHTMLHREF_setMorphFirst, METH_VARARGS, NULL},
	 { "OSISHTMLHREF_setRenderNoteNumbers", _wrap_OSISHTMLHREF_setRenderNoteNumbers, METH_VARARGS, NULL},
	 { "delete_OSISHTMLHREF", _wrap_delete_OSISHTMLHREF, METH_O, NULL},
	 { "OSISHTMLHREF_swigregister", OSISHTMLHREF_swigregister, METH_O, NULL},
	 { "OSISHTMLHREF_swiginit", OSISHTMLHREF_swiginit, METH_VARARGS, NULL},
	 { "new_ThMLHTMLHREF", _wrap_new_ThMLHTMLHREF, METH_NOARGS, NULL},
	 { "ThMLHTMLHREF_getImagePrefix", _wrap_ThMLHTMLHREF_getImagePrefix, METH_O, NULL},
	 { "ThMLHTMLHREF_setImagePrefix", _wrap_ThMLHTMLHREF_setImagePrefix, METH_VARARGS, NULL},
	 { "ThMLHTMLHREF_setRenderNoteNumbers", _wrap_ThMLHTMLHREF_setRenderNoteNumbers, METH_VARARGS, NULL},
	 { "delete_ThMLHTMLHREF", _wrap_delete_ThMLHTMLHREF, METH_O, NULL},
	 { "ThMLHTMLHREF_swigregister", ThMLHTMLHREF_swigregister, METH_O, NULL},
	 { "ThMLHTMLHREF_swiginit", ThMLHTMLHREF_swiginit, METH_VARARGS, NULL},
	 { "new_GBFHTMLHREF", _wrap_new_GBFHTMLHREF, METH_NOARGS, NULL},
	 { "GBFHTMLHREF_setRenderNoteNumbers", _wrap_GBFHTMLHREF_setRenderNoteNumbers, METH_VARARGS, NULL},
	 { "delete_GBFHTMLHREF", _wrap_delete_GBFHTMLHREF, METH_O, NULL},
	 { "GBFHTMLHREF_swigregister", GBFHTMLHREF_swigregister, METH_O, NULL},
	 { "GBFHTMLHREF_swiginit", GBFHTMLHREF_swiginit, METH_VARARGS, NULL},
	 { "new_UTF8HTML", _wrap_new_UTF8HTML, METH_NOARGS, NULL},
	 { "UTF8HTML_processText", _wrap_UTF8HTML_processText, METH_VARARGS, NULL},
	 { "delete_UTF8HTML", _wrap_delete_UTF8HTML, METH_O, NULL},
	 { "UTF8HTML_swigregister", UTF8HTML_swigregister, METH_O, NULL},
	 { "UTF8HTML_swiginit", UTF8HTML_swiginit, METH_VARARGS, NULL},
	 { "delete_MarkupCallback", _wrap_delete_MarkupCallback, METH_O, NULL},
	 { "MarkupCallback_run", _wrap_MarkupCallback_run, METH_VARARGS, NULL},
	 { "new_MarkupCallback", _wrap_new_MarkupCallback, METH_O, NULL},
	 { "disown_MarkupCallback", _wrap_disown_MarkupCallback, METH_O, NULL},
	 { "MarkupCallback_swigregister", MarkupCallback_swigregister, METH_O, NULL},
	 { "MarkupCallback_swiginit", MarkupCallback_swiginit, METH_VARARGS, NULL},
	 { "new_MyMarkup", _wrap_new_MyMarkup, METH_VARARGS, NULL},
	 { "delete_MyMarkup", _wrap_delete_MyMarkup, METH_O, NULL},
	 { "MyMarkup_delCallback", _wrap_MyMarkup_delCallback, METH_O, NULL},
	 { "MyMarkup_setCallback", _wrap_MyMarkup_setCallback, METH_VARARGS, NULL},
	 { "MyMarkup_call", _wrap_MyMarkup_call, METH_VARARGS, NULL},
	 { "MyMarkup_swigregister", MyMarkup_swigregister, METH_O, NULL},
	 { "MyMarkup_swiginit", MyMarkup_swiginit, METH_VARARGS, NULL},
	 { "new_ReturnSuccess", _wrap_new_ReturnSuccess, METH_VARARGS, NULL},
	 { "delete_ReturnSuccess", _wrap_delete_ReturnSuccess, METH_O, NULL},
	 { "ReturnSuccess_data_set", _wrap_ReturnSuccess_data_set, METH_VARARGS, NULL},
	 { "ReturnSuccess_data_get", _wrap_ReturnSuccess_data_get, METH_O, NULL},
	 { "ReturnSuccess_success_set", _wrap_ReturnSuccess_success_set, METH_VARARGS, NULL},
	 { "ReturnSuccess_success_get", _wrap_ReturnSuccess_success_get, METH_O, NULL},
	 { "ReturnSuccess_swigregister", ReturnSuccess_swigregister, METH_O, NULL},
	 { "ReturnSuccess_swiginit", ReturnSuccess_swiginit, METH_VARARGS, NULL},
	 { "delete_RenderCallback", _wrap_delete_RenderCallback, METH_O, NULL},
	 { "RenderCallback_run", _wrap_RenderCallback_run, METH_VARARGS, NULL},
	 { "new_RenderCallback", _wrap_new_RenderCallback, METH_O, NULL},
	 { "disown_RenderCallback", _wrap_disown_RenderCallback, METH_O, NULL},
	 { "RenderCallback_swigregister", RenderCallback_swigregister, METH_O, NULL},
	 { "RenderCallback_swiginit", RenderCallback_swiginit, METH_VARARGS, NULL},
	 { "PyOSISHTMLHREF_removeTokenSubstitute", _wrap_PyOSISHTMLHREF_removeTokenSubstitute, METH_VARARGS, NULL},
	 { "PyOSISHTMLHREF_addTokenSubstitute", _wrap_PyOSISHTMLHREF_addTokenSubstitute, METH_VARARGS, NULL},
	 { "PyOSISHTMLHREF_addAllowedEscapeString", _wrap_PyOSISHTMLHREF_addAllowedEscapeString, METH_VARARGS, NULL},
	 { "PyOSISHTMLHREF_removeAllowedEscapeString", _wrap_PyOSISHTMLHREF_removeAllowedEscapeString, METH_VARARGS, NULL},
	 { "new_PyOSISHTMLHREF", _wrap_new_PyOSISHTMLHREF, METH_O, NULL},
	 { "PyOSISHTMLHREF_getData", _wrap_PyOSISHTMLHREF_getData, METH_O, NULL},
	 { "delete_PyOSISHTMLHREF", _wrap_delete_PyOSISHTMLHREF, METH_O, NULL},
	 { "PyOSISHTMLHREF_delCallback", _wrap_PyOSISHTMLHREF_delCallback, METH_O, NULL},
	 { "PyOSISHTMLHREF_setCallback", _wrap_PyOSISHTMLHREF_setCallback, METH_VARARGS, NULL},
	 { "PyOSISHTMLHREF_call", _wrap_PyOSISHTMLHREF_call, METH_VARARGS, NULL},
	 { "PyOSISHTMLHREF_swigregister", PyOSISHTMLHREF_swigregister, METH_O, NULL},
	 { "PyOSISHTMLHREF_swiginit", PyOSISHTMLHREF_swiginit, METH_VARARGS, NULL},
	 { "PyThMLHTMLHREF_removeTokenSubstitute", _wrap_PyThMLHTMLHREF_removeTokenSubstitute, METH_VARARGS, NULL},
	 { "PyThMLHTMLHREF_addTokenSubstitute", _wrap_PyThMLHTMLHREF_addTokenSubstitute, METH_VARARGS, NULL},
	 { "PyThMLHTMLHREF_addAllowedEscapeString", _wrap_PyThMLHTMLHREF_addAllowedEscapeString, METH_VARARGS, NULL},
	 { "PyThMLHTMLHREF_removeAllowedEscapeString", _wrap_PyThMLHTMLHREF_removeAllowedEscapeString, METH_VARARGS, NULL},
	 { "new_PyThMLHTMLHREF", _wrap_new_PyThMLHTMLHREF, METH_O, NULL},
	 { "PyThMLHTMLHREF_getData", _wrap_PyThMLHTMLHREF_getData, METH_O, NULL},
	 { "delete_PyThMLHTMLHREF", _wrap_delete_PyThMLHTMLHREF, METH_O, NULL},
	 { "PyThMLHTMLHREF_delCallback", _wrap_PyThMLHTMLHREF_delCallback, METH_O, NULL},
	 { "PyThMLHTMLHREF_setCallback", _wrap_PyThMLHTMLHREF_setCallback, METH_VARARGS, NULL},
	 { "PyThMLHTMLHREF_call", _wrap_PyThMLHTMLHREF_call, METH_VARARGS, NULL},
	 { "PyThMLHTMLHREF_swigregister", PyThMLHTMLHREF_swigregister, METH_O, NULL},
	 { "PyThMLHTMLHREF_swiginit", PyThMLHTMLHREF_swiginit, METH_VARARGS, NULL},
	 { "OSISData_osisQToTick_set", _wrap_OSISData_osisQToTick_set, METH_VARARGS, NULL},
	 { "OSISData_osisQToTick_get", _wrap_OSISData_osisQToTick_get, METH_O, NULL},
	 { "OSISData_inBold_set", _wrap_OSISData_inBold_set, METH_VARARGS, NULL},
	 { "OSISData_inBold_get", _wrap_OSISData_inBold_get, METH_O, NULL},
	 { "OSISData_inXRefNote_set", _wrap_OSISData_inXRefNote_set, METH_VARARGS, NULL},
	 { "OSISData_inXRefNote_get", _wrap_OSISData_inXRefNote_get, METH_O, NULL},
	 { "OSISData_isBiblicalText_set", _wrap_OSISData_isBiblicalText_set, METH_VARARGS, NULL},
	 { "OSISData_isBiblicalText_get", _wrap_OSISData_isBiblicalText_get, METH_O, NULL},
	 { "OSISData_suspendLevel_set", _wrap_OSISData_suspendLevel_set, METH_VARARGS, NULL},
	 { "OSISData_suspendLevel_get", _wrap_OSISData_suspendLevel_get, METH_O, NULL},
	 { "OSISData_wordsOfChristStart_set", _wrap_OSISData_wordsOfChristStart_set, METH_VARARGS, NULL},
	 { "OSISData_wordsOfChristStart_get", _wrap_OSISData_wordsOfChristStart_get, METH_O, NULL},
	 { "OSISData_wordsOfChristEnd_set", _wrap_OSISData_wordsOfChristEnd_set, METH_VARARGS, NULL},
	 { "OSISData_wordsOfChristEnd_get", _wrap_OSISData_wordsOfChristEnd_get, METH_O, NULL},
	 { "OSISData_lastTransChange_set", _wrap_OSISData_lastTransChange_set, METH_VARARGS, NULL},
	 { "OSISData_lastTransChange_get", _wrap_OSISData_lastTransChange_get, METH_O, NULL},
	 { "OSISData_w_set", _wrap_OSISData_w_set, METH_VARARGS, NULL},
	 { "OSISData_w_get", _wrap_OSISData_w_get, METH_O, NULL},
	 { "OSISData_fn_set", _wrap_OSISData_fn_set, METH_VARARGS, NULL},
	 { "OSISData_fn_get", _wrap_OSISData_fn_get, METH_O, NULL},
	 { "OSISData_version_set", _wrap_OSISData_version_set, METH_VARARGS, NULL},
	 { "OSISData_version_get", _wrap_OSISData_version_get, METH_O, NULL},
	 { "delete_OSISData", _wrap_delete_OSISData, METH_O, NULL},
	 { "OSISData_swigregister", OSISData_swigregister, METH_O, NULL},
	 { "ThMLData_inscriptRef_set", _wrap_ThMLData_inscriptRef_set, METH_VARARGS, NULL},
	 { "ThMLData_inscriptRef_get", _wrap_ThMLData_inscriptRef_get, METH_O, NULL},
	 { "ThMLData_inSecHead_set", _wrap_ThMLData_inSecHead_set, METH_VARARGS, NULL},
	 { "ThMLData_inSecHead_get", _wrap_ThMLData_inSecHead_get, METH_O, NULL},
	 { "ThMLData_isBiblicalText_set", _wrap_ThMLData_isBiblicalText_set, METH_VARARGS, NULL},
	 { "ThMLData_isBiblicalText_get", _wrap_ThMLData_isBiblicalText_get, METH_O, NULL},
	 { "ThMLData_version_set", _wrap_ThMLData_version_set, METH_VARARGS, NULL},
	 { "ThMLData_version_get", _wrap_ThMLData_version_get, METH_O, NULL},
	 { "ThMLData_startTag_set", _wrap_ThMLData_startTag_set, METH_VARARGS, NULL},
	 { "ThMLData_startTag_get", _wrap_ThMLData_startTag_get, METH_O, NULL},
	 { "delete_ThMLData", _wrap_delete_ThMLData, METH_O, NULL},
	 { "ThMLData_swigregister", ThMLData_swigregister, METH_O, NULL},
	 { "SWSearcher_mod_set", _wrap_SWSearcher_mod_set, METH_VARARGS, NULL},
	 { "SWSearcher_mod_get", _wrap_SWSearcher_mod_get, METH_O, NULL},
	 { "SWSearcher_percent_set", _wrap_SWSearcher_percent_set, METH_VARARGS, NULL},
	 { "SWSearcher_percent_get", _wrap_SWSearcher_percent_get, METH_O, NULL},
	 { "SWSearcher_Callback", _wrap_SWSearcher_Callback, METH_VARARGS, NULL},
	 { "SWSearcher_PercentFunction", _wrap_SWSearcher_PercentFunction, METH_VARARGS, NULL},
	 { "new_SWSearcher", _wrap_new_SWSearcher, METH_VARARGS, NULL},
	 { "delete_SWSearcher", _wrap_delete_SWSearcher, METH_O, NULL},
	 { "SWSearcher_GetPercent", _wrap_SWSearcher_GetPercent, METH_O, NULL},
	 { "SWSearcher_isSearchSupported", _wrap_SWSearcher_isSearchSupported, METH_VARARGS, NULL},
	 { "SWSearcher_doSearch", _wrap_SWSearcher_doSearch, METH_VARARGS, NULL},
	 { "SWSearcher_TerminateSearch", _wrap_SWSearcher_TerminateSearch, METH_O, NULL},
	 { "disown_SWSearcher", _wrap_disown_SWSearcher, METH_O, NULL},
	 { "SWSearcher_swigregister", SWSearcher_swigregister, METH_O, NULL},
	 { "SWSearcher_swiginit", SWSearcher_swiginit, METH_VARARGS, NULL},
	 { "SWLog_getSystemLog", _wrap_SWLog_getSystemLog, METH_NOARGS, NULL},
	 { "SWLog_setSystemLog", _wrap_SWLog_setSystemLog, METH_O, NULL},
	 { "new_SWLog", _wrap_new_SWLog, METH_NOARGS, NULL},
	 { "delete_SWLog", _wrap_delete_SWLog, METH_O, NULL},
	 { "SWLog_setLogLevel", _wrap_SWLog_setLogLevel, METH_VARARGS, NULL},
	 { "SWLog_getLogLevel", _wrap_SWLog_getLogLevel, METH_O, NULL},
	 { "SWLog_logWarning", _wrap_SWLog_logWarning, METH_VARARGS, NULL},
	 { "SWLog_logError", _wrap_SWLog_logError, METH_VARARGS, NULL},
	 { "SWLog_logInformation", _wrap_SWLog_logInformation, METH_VARARGS, NULL},
	 { "SWLog_logDebug", _wrap_SWLog_logDebug, METH_VARARGS, NULL},
	 { "SWLog_logMessage", _wrap_SWLog_logMessage, METH_VARARGS, NULL},
	 { "SWLog_logTimedInformation", _wrap_SWLog_logTimedInformation, METH_VARARGS, NULL},
	 { "SWLog_swigregister", SWLog_swigregister, METH_O, NULL},
	 { "SWLog_swiginit", SWLog_swiginit, METH_VARARGS, NULL},
	 { "delete_StatusReporter", _wrap_delete_StatusReporter, METH_O, NULL},
	 { "StatusReporter_preStatus", _wrap_StatusReporter_preStatus, METH_VARARGS, NULL},
	 { "StatusReporter_update", _wrap_StatusReporter_update, METH_VARARGS, NULL},
	 { "new_StatusReporter", _wrap_new_StatusReporter, METH_O, NULL},
	 { "disown_StatusReporter", _wrap_disown_StatusReporter, METH_O, NULL},
	 { "StatusReporter_swigregister", StatusReporter_swigregister, METH_O, NULL},
	 { "StatusReporter_swiginit", StatusReporter_swiginit, METH_VARARGS, NULL},
	 { "new_RemoteTransport", _wrap_new_RemoteTransport, METH_VARARGS, NULL},
	 { "delete_RemoteTransport", _wrap_delete_RemoteTransport, METH_O, NULL},
	 { "RemoteTransport_getURL", _wrap_RemoteTransport_getURL, METH_VARARGS, NULL},
	 { "RemoteTransport_putURL", _wrap_RemoteTransport_putURL, METH_VARARGS, NULL},
	 { "RemoteTransport_copyDirectory", _wrap_RemoteTransport_copyDirectory, METH_VARARGS, NULL},
	 { "RemoteTransport_getDirList", _wrap_RemoteTransport_getDirList, METH_VARARGS, NULL},
	 { "RemoteTransport_setPassive", _wrap_RemoteTransport_setPassive, METH_VARARGS, NULL},
	 { "RemoteTransport_setTimeoutMillis", _wrap_RemoteTransport_setTimeoutMillis, METH_VARARGS, NULL},
	 { "RemoteTransport_getTimeoutMillis", _wrap_RemoteTransport_getTimeoutMillis, METH_O, NULL},
	 { "RemoteTransport_isPassive", _wrap_RemoteTransport_isPassive, METH_O, NULL},
	 { "RemoteTransport_setUser", _wrap_RemoteTransport_setUser, METH_VARARGS, NULL},
	 { "RemoteTransport_setPasswd", _wrap_RemoteTransport_setPasswd, METH_VARARGS, NULL},
	 { "RemoteTransport_setUnverifiedPeerAllowed", _wrap_RemoteTransport_setUnverifiedPeerAllowed, METH_VARARGS, NULL},
	 { "RemoteTransport_isUnverifiedPeerAllowed", _wrap_RemoteTransport_isUnverifiedPeerAllowed, METH_O, NULL},
	 { "RemoteTransport_terminate", _wrap_RemoteTransport_terminate, METH_O, NULL},
	 { "RemoteTransport_swigregister", RemoteTransport_swigregister, METH_O, NULL},
	 { "RemoteTransport_swiginit", RemoteTransport_swiginit, METH_VARARGS, NULL},
	 { "new_InstallSource", _wrap_new_InstallSource, METH_VARARGS, NULL},
	 { "delete_InstallSource", _wrap_delete_InstallSource, METH_O, NULL},
	 { "InstallSource_getConfEnt", _wrap_InstallSource_getConfEnt, METH_O, NULL},
	 { "InstallSource_caption_set", _wrap_InstallSource_caption_set, METH_VARARGS, NULL},
	 { "InstallSource_caption_get", _wrap_InstallSource_caption_get, METH_O, NULL},
	 { "InstallSource_source_set", _wrap_InstallSource_source_set, METH_VARARGS, NULL},
	 { "InstallSource_source_get", _wrap_InstallSource_source_get, METH_O, NULL},
	 { "InstallSource_directory_set", _wrap_InstallSource_directory_set, METH_VARARGS, NULL},
	 { "InstallSource_directory_get", _wrap_InstallSource_directory_get, METH_O, NULL},
	 { "InstallSource_u_set", _wrap_InstallSource_u_set, METH_VARARGS, NULL},
	 { "InstallSource_u_get", _wrap_InstallSource_u_get, METH_O, NULL},
	 { "InstallSource_p_set", _wrap_InstallSource_p_set, METH_VARARGS, NULL},
	 { "InstallSource_p_get", _wrap_InstallSource_p_get, METH_O, NULL},
	 { "InstallSource_uid_set", _wrap_InstallSource_uid_set, METH_VARARGS, NULL},
	 { "InstallSource_uid_get", _wrap_InstallSource_uid_get, METH_O, NULL},
	 { "InstallSource_type_set", _wrap_InstallSource_type_set, METH_VARARGS, NULL},
	 { "InstallSource_type_get", _wrap_InstallSource_type_get, METH_O, NULL},
	 { "InstallSource_localShadow_set", _wrap_InstallSource_localShadow_set, METH_VARARGS, NULL},
	 { "InstallSource_localShadow_get", _wrap_InstallSource_localShadow_get, METH_O, NULL},
	 { "InstallSource_getMgr", _wrap_InstallSource_getMgr, METH_O, NULL},
	 { "InstallSource_flush", _wrap_InstallSource_flush, METH_O, NULL},
	 { "InstallSource_swigregister", InstallSource_swigregister, METH_O, NULL},
	 { "InstallSource_swiginit", InstallSource_swiginit, METH_VARARGS, NULL},
	 { "InstallMgr_userDisclaimerConfirmed_get", _wrap_InstallMgr_userDisclaimerConfirmed_get, METH_VARARGS, NULL},
	 { "InstallMgr_userDisclaimerConfirmed_set", _wrap_InstallMgr_userDisclaimerConfirmed_set, METH_O, NULL},
	 { "InstallMgr_installConf_set", _wrap_InstallMgr_installConf_set, METH_VARARGS, NULL},
	 { "InstallMgr_installConf_get", _wrap_InstallMgr_installConf_get, METH_O, NULL},
	 { "InstallMgr_sources_set", _wrap_InstallMgr_sources_set, METH_VARARGS, NULL},
	 { "InstallMgr_sources_get", _wrap_InstallMgr_sources_get, METH_O, NULL},
	 { "new_InstallMgr", _wrap_new_InstallMgr, METH_VARARGS, NULL},
	 { "delete_InstallMgr", _wrap_delete_InstallMgr, METH_O, NULL},
	 { "InstallMgr_readInstallConf", _wrap_InstallMgr_readInstallConf, METH_O, NULL},
	 { "InstallMgr_saveInstallConf", _wrap_InstallMgr_saveInstallConf, METH_O, NULL},
	 { "InstallMgr_clearSources", _wrap_InstallMgr_clearSources, METH_O, NULL},
	 { "InstallMgr_removeModule", _wrap_InstallMgr_removeModule, METH_VARARGS, NULL},
	 { "InstallMgr_remoteCopy", _wrap_InstallMgr_remoteCopy, METH_VARARGS, NULL},
	 { "InstallMgr_installModule", _wrap_InstallMgr_installModule, METH_VARARGS, NULL},
	 { "InstallMgr_refreshRemoteSource", _wrap_InstallMgr_refreshRemoteSource, METH_VARARGS, NULL},
	 { "InstallMgr_refreshRemoteSourceConfiguration", _wrap_InstallMgr_refreshRemoteSourceConfiguration, METH_O, NULL},
	 { "InstallMgr_isUserDisclaimerConfirmed", _wrap_InstallMgr_isUserDisclaimerConfirmed, METH_O, NULL},
	 { "InstallMgr_setUserDisclaimerConfirmed", _wrap_InstallMgr_setUserDisclaimerConfirmed, METH_VARARGS, NULL},
	 { "InstallMgr_getCipherCode", _wrap_InstallMgr_getCipherCode, METH_VARARGS, NULL},
	 { "InstallMgr_setFTPPassive", _wrap_InstallMgr_setFTPPassive, METH_VARARGS, NULL},
	 { "InstallMgr_isFTPPassive", _wrap_InstallMgr_isFTPPassive, METH_O, NULL},
	 { "InstallMgr_setTimeoutMillis", _wrap_InstallMgr_setTimeoutMillis, METH_VARARGS, NULL},
	 { "InstallMgr_getTimeoutMillis", _wrap_InstallMgr_getTimeoutMillis, METH_O, NULL},
	 { "InstallMgr_setUnverifiedPeerAllowed", _wrap_InstallMgr_setUnverifiedPeerAllowed, METH_VARARGS, NULL},
	 { "InstallMgr_isUnverifiedPeerAllowed", _wrap_InstallMgr_isUnverifiedPeerAllowed, METH_O, NULL},
	 { "InstallMgr_terminate", _wrap_InstallMgr_terminate, METH_O, NULL},
	 { "InstallMgr_getModuleStatus", _wrap_InstallMgr_getModuleStatus, METH_VARARGS, NULL},
	 { "InstallMgr_isDefaultModule", _wrap_InstallMgr_isDefaultModule, METH_VARARGS, NULL},
	 { "InstallMgr_swigregister", InstallMgr_swigregister, METH_O, NULL},
	 { "InstallMgr_swiginit", InstallMgr_swiginit, METH_VARARGS, NULL},
	 { NULL, NULL, 0, NULL }
};


/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */

static void *_p_OSISDataTo_p_sword__BasicFilterUserData(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((sword::BasicFilterUserData *)  ((OSISData *) x));
}
static void *_p_ThMLDataTo_p_sword__BasicFilterUserData(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((sword::BasicFilterUserData *)  ((ThMLData *) x));
}
static void *_p_MyMarkupTo_p_sword__EncodingFilterMgr(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((sword::EncodingFilterMgr *) (sword::MarkupFilterMgr *) ((MyMarkup *) x));
}
static void *_p_sword__MarkupFilterMgrTo_p_sword__EncodingFilterMgr(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((sword::EncodingFilterMgr *)  ((sword::MarkupFilterMgr *) x));
}
static void *_p_MyMarkupTo_p_sword__MarkupFilterMgr(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((sword::MarkupFilterMgr *)  ((MyMarkup *) x));
}
static void *_p_PyOSISHTMLHREFTo_p_sword__OSISHTMLHREF(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((sword::OSISHTMLHREF *)  ((PyOSISHTMLHREF *) x));
}
static void *_p_sword__RawLDTo_p_sword__RawStr(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((sword::RawStr *)  ((sword::RawLD *) x));
}
static void *_p_sword__RawLD4To_p_sword__RawStr4(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((sword::RawStr4 *)  ((sword::RawLD4 *) x));
}
static void *_p_sword__RawComTo_p_sword__RawVerse(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((sword::RawVerse *)  ((sword::RawCom *) x));
}
static void *_p_sword__RawTextTo_p_sword__RawVerse(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((sword::RawVerse *)  ((sword::RawText *) x));
}
static void *_p_PyOSISHTMLHREFTo_p_sword__SWBasicFilter(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((sword::SWBasicFilter *) (sword::OSISHTMLHREF *) ((PyOSISHTMLHREF *) x));
}
static void *_p_PyThMLHTMLHREFTo_p_sword__SWBasicFilter(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((sword::SWBasicFilter *) (sword::ThMLHTMLHREF *) ((PyThMLHTMLHREF *) x));
}
static void *_p_sword__GBFHTMLHREFTo_p_sword__SWBasicFilter(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((sword::SWBasicFilter *)  ((sword::GBFHTMLHREF *) x));
}
static void *_p_sword__OSISHTMLHREFTo_p_sword__SWBasicFilter(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((sword::SWBasicFilter *)  ((sword::OSISHTMLHREF *) x));
}
static void *_p_sword__ThMLHTMLHREFTo_p_sword__SWBasicFilter(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((sword::SWBasicFilter *)  ((sword::ThMLHTMLHREF *) x));
}
static void *_p_sword__RawComTo_p_sword__SWCom(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((sword::SWCom *)  ((sword::RawCom *) x));
}
static void *_p_sword__zComTo_p_sword__SWCom(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((sword::SWCom *)  ((sword::zCom *) x));
}
static void *_p_sword__LZSSCompressTo_p_sword__SWCompress(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((sword::SWCompress *)  ((sword::LZSSCompress *) x));
}
static void *_p_sword__ZipCompressTo_p_sword__SWCompress(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((sword::SWCompress *)  ((sword::ZipCompress *) x));
}
static void *_p_PyOSISHTMLHREFTo_p_sword__SWFilter(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((sword::SWFilter *) (sword::SWBasicFilter *)(sword::OSISHTMLHREF *) ((PyOSISHTMLHREF *) x));
}
static void *_p_PyThMLHTMLHREFTo_p_sword__SWFilter(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((sword::SWFilter *) (sword::SWBasicFilter *)(sword::ThMLHTMLHREF *) ((PyThMLHTMLHREF *) x));
}
static void *_p_sword__GBFHTMLHREFTo_p_sword__SWFilter(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((sword::SWFilter *) (sword::SWBasicFilter *) ((sword::GBFHTMLHREF *) x));
}
static void *_p_sword__OSISHTMLHREFTo_p_sword__SWFilter(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((sword::SWFilter *) (sword::SWBasicFilter *) ((sword::OSISHTMLHREF *) x));
}
static void *_p_sword__SWBasicFilterTo_p_sword__SWFilter(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((sword::SWFilter *)  ((sword::SWBasicFilter *) x));
}
static void *_p_sword__SWOptionFilterTo_p_sword__SWFilter(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((sword::SWFilter *)  ((sword::SWOptionFilter *) x));
}
static void *_p_sword__ThMLHTMLHREFTo_p_sword__SWFilter(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((sword::SWFilter *) (sword::SWBasicFilter *) ((sword::ThMLHTMLHREF *) x));
}
static void *_p_sword__UTF8HTMLTo_p_sword__SWFilter(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((sword::SWFilter *)  ((sword::UTF8HTML *) x));
}
static void *_p_MyMarkupTo_p_sword__SWFilterMgr(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((sword::SWFilterMgr *) (sword::EncodingFilterMgr *)(sword::MarkupFilterMgr *) ((MyMarkup *) x));
}
static void *_p_sword__EncodingFilterMgrTo_p_sword__SWFilterMgr(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((sword::SWFilterMgr *)  ((sword::EncodingFilterMgr *) x));
}
static void *_p_sword__MarkupFilterMgrTo_p_sword__SWFilterMgr(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((sword::SWFilterMgr *) (sword::EncodingFilterMgr *) ((sword::MarkupFilterMgr *) x));
}
static void *_p_sword__RawGenBookTo_p_sword__SWGenBook(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((sword::SWGenBook *)  ((sword::RawGenBook *) x));
}
static void *_p_sword__ListKeyTo_p_sword__SWKey(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((sword::SWKey *)  ((sword::ListKey *) x));
}
static void *_p_sword__TreeKeyTo_p_sword__SWKey(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((sword::SWKey *)  ((sword::TreeKey *) x));
}
static void *_p_sword__TreeKeyIdxTo_p_sword__SWKey(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((sword::SWKey *) (sword::TreeKey *) ((sword::TreeKeyIdx *) x));
}
static void *_p_sword__VerseKeyTo_p_sword__SWKey(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((sword::SWKey *)  ((sword::VerseKey *) x));
}
static void *_p_sword__VerseTreeKeyTo_p_sword__SWKey(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((sword::SWKey *) (sword::VerseKey *) ((sword::VerseTreeKey *) x));
}
static void *_p_sword__RawLDTo_p_sword__SWLD(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((sword::SWLD *)  ((sword::RawLD *) x));
}
static void *_p_sword__RawLD4To_p_sword__SWLD(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((sword::SWLD *)  ((sword::RawLD4 *) x));
}
static void *_p_sword__zLDTo_p_sword__SWLD(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((sword::SWLD *)  ((sword::zLD *) x));
}
static void *_p_sword__RawComTo_p_sword__SWModule(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((sword::SWModule *) (sword::SWCom *) ((sword::RawCom *) x));
}
static void *_p_sword__RawGenBookTo_p_sword__SWModule(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((sword::SWModule *) (sword::SWGenBook *) ((sword::RawGenBook *) x));
}
static void *_p_sword__RawLDTo_p_sword__SWModule(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((sword::SWModule *) (sword::SWLD *) ((sword::RawLD *) x));
}
static void *_p_sword__RawLD4To_p_sword__SWModule(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((sword::SWModule *) (sword::SWLD *) ((sword::RawLD4 *) x));
}
static void *_p_sword__RawTextTo_p_sword__SWModule(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((sword::SWModule *) (sword::SWText *) ((sword::RawText *) x));
}
static void *_p_sword__SWComTo_p_sword__SWModule(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((sword::SWModule *)  ((sword::SWCom *) x));
}
static void *_p_sword__SWGenBookTo_p_sword__SWModule(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((sword::SWModule *)  ((sword::SWGenBook *) x));
}
static void *_p_sword__SWLDTo_p_sword__SWModule(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((sword::SWModule *)  ((sword::SWLD *) x));
}
static void *_p_sword__SWTextTo_p_sword__SWModule(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((sword::SWModule *)  ((sword::SWText *) x));
}
static void *_p_sword__zComTo_p_sword__SWModule(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((sword::SWModule *) (sword::SWCom *) ((sword::zCom *) x));
}
static void *_p_sword__zLDTo_p_sword__SWModule(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((sword::SWModule *) (sword::SWLD *) ((sword::zLD *) x));
}
static void *_p_sword__zTextTo_p_sword__SWModule(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((sword::SWModule *) (sword::SWText *) ((sword::zText *) x));
}
static void *_p_sword__ListKeyTo_p_sword__SWObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((sword::SWObject *) (sword::SWKey *) ((sword::ListKey *) x));
}
static void *_p_sword__SWDisplayTo_p_sword__SWObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((sword::SWObject *)  ((sword::SWDisplay *) x));
}
static void *_p_sword__SWKeyTo_p_sword__SWObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((sword::SWObject *)  ((sword::SWKey *) x));
}
static void *_p_sword__TreeKeyTo_p_sword__SWObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((sword::SWObject *) (sword::SWKey *) ((sword::TreeKey *) x));
}
static void *_p_sword__TreeKeyIdxTo_p_sword__SWObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((sword::SWObject *) (sword::SWKey *)(sword::TreeKey *) ((sword::TreeKeyIdx *) x));
}
static void *_p_sword__VerseKeyTo_p_sword__SWObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((sword::SWObject *) (sword::SWKey *) ((sword::VerseKey *) x));
}
static void *_p_sword__VerseTreeKeyTo_p_sword__SWObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((sword::SWObject *) (sword::SWKey *)(sword::VerseKey *) ((sword::VerseTreeKey *) x));
}
static void *_p_sword__RawComTo_p_sword__SWSearchable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((sword::SWSearchable *) (sword::SWModule *)(sword::SWCom *) ((sword::RawCom *) x));
}
static void *_p_sword__RawGenBookTo_p_sword__SWSearchable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((sword::SWSearchable *) (sword::SWModule *)(sword::SWGenBook *) ((sword::RawGenBook *) x));
}
static void *_p_sword__RawLDTo_p_sword__SWSearchable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((sword::SWSearchable *) (sword::SWModule *)(sword::SWLD *) ((sword::RawLD *) x));
}
static void *_p_sword__RawLD4To_p_sword__SWSearchable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((sword::SWSearchable *) (sword::SWModule *)(sword::SWLD *) ((sword::RawLD4 *) x));
}
static void *_p_sword__RawTextTo_p_sword__SWSearchable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((sword::SWSearchable *) (sword::SWModule *)(sword::SWText *) ((sword::RawText *) x));
}
static void *_p_sword__SWComTo_p_sword__SWSearchable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((sword::SWSearchable *) (sword::SWModule *) ((sword::SWCom *) x));
}
static void *_p_sword__SWGenBookTo_p_sword__SWSearchable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((sword::SWSearchable *) (sword::SWModule *) ((sword::SWGenBook *) x));
}
static void *_p_sword__SWLDTo_p_sword__SWSearchable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((sword::SWSearchable *) (sword::SWModule *) ((sword::SWLD *) x));
}
static void *_p_sword__SWModuleTo_p_sword__SWSearchable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((sword::SWSearchable *)  ((sword::SWModule *) x));
}
static void *_p_sword__SWTextTo_p_sword__SWSearchable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((sword::SWSearchable *) (sword::SWModule *) ((sword::SWText *) x));
}
static void *_p_sword__zComTo_p_sword__SWSearchable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((sword::SWSearchable *) (sword::SWModule *)(sword::SWCom *) ((sword::zCom *) x));
}
static void *_p_sword__zLDTo_p_sword__SWSearchable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((sword::SWSearchable *) (sword::SWModule *)(sword::SWLD *) ((sword::zLD *) x));
}
static void *_p_sword__zTextTo_p_sword__SWSearchable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((sword::SWSearchable *) (sword::SWModule *)(sword::SWText *) ((sword::zText *) x));
}
static void *_p_sword__RawTextTo_p_sword__SWText(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((sword::SWText *)  ((sword::RawText *) x));
}
static void *_p_sword__zTextTo_p_sword__SWText(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((sword::SWText *)  ((sword::zText *) x));
}
static void *_p_PyStringMgrTo_p_sword__StringMgr(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((sword::StringMgr *)  ((PyStringMgr *) x));
}
static void *_p_PyThMLHTMLHREFTo_p_sword__ThMLHTMLHREF(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((sword::ThMLHTMLHREF *)  ((PyThMLHTMLHREF *) x));
}
static void *_p_sword__TreeKeyIdxTo_p_sword__TreeKey(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((sword::TreeKey *)  ((sword::TreeKeyIdx *) x));
}
static void *_p_sword__VerseTreeKeyTo_p_sword__VerseKey(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((sword::VerseKey *)  ((sword::VerseTreeKey *) x));
}
static void *_p_sword__zLDTo_p_sword__zStr(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((sword::zStr *)  ((sword::zLD *) x));
}
static void *_p_sword__zComTo_p_sword__zVerse(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((sword::zVerse *)  ((sword::zCom *) x));
}
static void *_p_sword__zTextTo_p_sword__zVerse(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((sword::zVerse *)  ((sword::zText *) x));
}
static swig_type_info _swigt__p_MarkupCallback = {"_p_MarkupCallback", "MarkupCallback *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_MyMarkup = {"_p_MyMarkup", "MyMarkup *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_OSISData = {"_p_OSISData", "OSISData *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ParameterMap = {"_p_ParameterMap", "ParameterMap *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_PyOSISHTMLHREF = {"_p_PyOSISHTMLHREF", "PyOSISHTMLHREF *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_PyStringMgr = {"_p_PyStringMgr", "PyStringMgr *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_PyThMLHTMLHREF = {"_p_PyThMLHTMLHREF", "PyThMLHTMLHREF *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_RenderCallback = {"_p_RenderCallback", "RenderCallback *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ReturnSuccess = {"_p_ReturnSuccess", "ReturnSuccess *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SWSearcher = {"_p_SWSearcher", "SWSearcher *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SW_u16 = {"_p_SW_u16", "SW_u16 *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SW_u32 = {"_p_SW_u32", "SW_u32 *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ThMLData = {"_p_ThMLData", "ThMLData *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_allocator_type = {"_p_allocator_type", "allocator_type *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_difference_type = {"_p_difference_type", "difference_type *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_first_type = {"_p_first_type", "first_type *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_key_type = {"_p_key_type", "key_type *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_long = {"_p_long", "long *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mapped_type = {"_p_mapped_type", "mapped_type *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p_PyObject = {"_p_p_PyObject", "PyObject **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p_char = {"_p_p_char", "char **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_second_type = {"_p_second_type", "second_type *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_size_type = {"_p_size_type", "size_type *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__allocatorT_std__pairT_sword__SWBuf_const_std__mapT_sword__SWBuf_AttributeValueMap_t_t_t = {"_p_std__allocatorT_std__pairT_sword__SWBuf_const_std__mapT_sword__SWBuf_AttributeValueMap_t_t_t", "std::allocator< std::pair< sword::SWBuf const,std::map< sword::SWBuf,AttributeValueMap,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,AttributeValueMap > > > > > *|std::map< sword::SWBuf,std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > > > > >::allocator_type *|std::allocator< std::pair< sword::SWBuf const,std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > > > > > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__allocatorT_std__pairT_sword__SWBuf_const_std__mapT_sword__SWBuf_sword__SWBuf_t_t_t = {"_p_std__allocatorT_std__pairT_sword__SWBuf_const_std__mapT_sword__SWBuf_sword__SWBuf_t_t_t", "std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > >::allocator_type *|std::allocator< std::pair< sword::SWBuf const,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__allocatorT_std__pairT_sword__SWBuf_const_std__multimapT_sword__SWBuf_sword__SWBuf_std__lessT_sword__SWBuf_t_t_t_t = {"_p_std__allocatorT_std__pairT_sword__SWBuf_const_std__multimapT_sword__SWBuf_sword__SWBuf_std__lessT_sword__SWBuf_t_t_t_t", "std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > >::allocator_type *|std::allocator< std::pair< sword::SWBuf const,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__allocatorT_std__pairT_sword__SWBuf_const_sword__InstallSource_p_t_t = {"_p_std__allocatorT_std__pairT_sword__SWBuf_const_sword__InstallSource_p_t_t", "std::map< sword::SWBuf,sword::InstallSource * >::allocator_type *|std::allocator< std::pair< sword::SWBuf const,sword::InstallSource * > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__allocatorT_std__pairT_sword__SWBuf_const_sword__SWBuf_t_t = {"_p_std__allocatorT_std__pairT_sword__SWBuf_const_sword__SWBuf_t_t", "std::map< sword::SWBuf,sword::SWBuf >::allocator_type *|std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > >::allocator_type *|std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__allocatorT_std__pairT_sword__SWBuf_const_sword__SWModule_p_t_t = {"_p_std__allocatorT_std__pairT_sword__SWBuf_const_sword__SWModule_p_t_t", "std::map< sword::SWBuf,sword::SWModule * >::allocator_type *|std::allocator< std::pair< sword::SWBuf const,sword::SWModule * > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__allocatorT_sword__DirEntry_t = {"_p_std__allocatorT_sword__DirEntry_t", "std::vector< sword::DirEntry >::allocator_type *|std::allocator< sword::DirEntry > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__allocatorT_sword__SWBuf_t = {"_p_std__allocatorT_sword__SWBuf_t", "std::list< sword::SWBuf >::allocator_type *|std::vector< sword::SWBuf >::allocator_type *|std::allocator< sword::SWBuf > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__invalid_argument = {"_p_std__invalid_argument", "std::invalid_argument *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__lessT_sword__SWBuf_t = {"_p_std__lessT_sword__SWBuf_t", "std::less< sword::SWBuf > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__listT_sword__SWBuf_t = {"_p_std__listT_sword__SWBuf_t", "std::list< sword::SWBuf,std::allocator< sword::SWBuf > > *|sword::StringList *|std::list< sword::SWBuf > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__listT_sword__SWFilter_p_std__allocatorT_sword__SWFilter_p_t_t = {"_p_std__listT_sword__SWFilter_p_std__allocatorT_sword__SWFilter_p_t_t", "sword::FilterList *|std::list< sword::SWFilter *,std::allocator< sword::SWFilter * > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__listT_sword__SWOptionFilter_p_std__allocatorT_sword__SWOptionFilter_p_t_t = {"_p_std__listT_sword__SWOptionFilter_p_std__allocatorT_sword__SWOptionFilter_p_t_t", "sword::OptionFilterList *|std::list< sword::SWOptionFilter *,std::allocator< sword::SWOptionFilter * > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__mapT_sword__SWBuf_AttributeListMap_t = {"_p_std__mapT_sword__SWBuf_AttributeListMap_t", "AttributeTypeListMap *|std::map< sword::SWBuf,AttributeListMap > *|std::map< sword::SWBuf,std::map< sword::SWBuf,AttributeValueMap,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,AttributeValueMap > > >,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,std::map< sword::SWBuf,AttributeValueMap,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,AttributeValueMap > > > > > > *|std::map< sword::SWBuf,std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > > > >,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > > > > > > > *|sword::AttributeTypeList *|std::map< sword::SWBuf,std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > > > > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__mapT_sword__SWBuf_AttributeValueMap_t = {"_p_std__mapT_sword__SWBuf_AttributeValueMap_t", "AttributeListMap *|std::map< sword::SWBuf,AttributeValueMap > *|std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > > > > *|sword::AttributeList *|std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__mapT_sword__SWBuf_std__multimapT_sword__SWBuf_sword__SWBuf_std__lessT_sword__SWBuf_t_t_t = {"_p_std__mapT_sword__SWBuf_std__multimapT_sword__SWBuf_sword__SWBuf_std__lessT_sword__SWBuf_t_t_t", "PySectionMap *|std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > > *|std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > > > > *|std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__mapT_sword__SWBuf_sword__InstallSource_p_t = {"_p_std__mapT_sword__SWBuf_sword__InstallSource_p_t", "std::map< sword::SWBuf,sword::InstallSource *,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::InstallSource * > > > *|sword::InstallSourceMap *|std::map< sword::SWBuf,sword::InstallSource * > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__mapT_sword__SWBuf_sword__SWBuf_t = {"_p_std__mapT_sword__SWBuf_sword__SWBuf_t", "AttributeValueMap *|std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > *|sword::AttributeValue *|sword::StringPairMap *|std::map< sword::SWBuf,sword::SWBuf > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__mapT_sword__SWBuf_sword__SWFilter_p_std__lessT_sword__SWBuf_t_std__allocatorT_std__pairT_sword__SWBuf_const_sword__SWFilter_p_t_t_t = {"_p_std__mapT_sword__SWBuf_sword__SWFilter_p_std__lessT_sword__SWBuf_t_std__allocatorT_std__pairT_sword__SWBuf_const_sword__SWFilter_p_t_t_t", "sword::FilterMap *|std::map< sword::SWBuf,sword::SWFilter *,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWFilter * > > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__mapT_sword__SWBuf_sword__SWLocale_p_std__lessT_sword__SWBuf_t_std__allocatorT_std__pairT_sword__SWBuf_const_sword__SWLocale_p_t_t_t = {"_p_std__mapT_sword__SWBuf_sword__SWLocale_p_std__lessT_sword__SWBuf_t_std__allocatorT_std__pairT_sword__SWBuf_const_sword__SWLocale_p_t_t_t", "sword::LocaleMap *|std::map< sword::SWBuf,sword::SWLocale *,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWLocale * > > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__mapT_sword__SWBuf_sword__SWModule_p_t = {"_p_std__mapT_sword__SWBuf_sword__SWModule_p_t", "std::map< sword::SWBuf,sword::SWModule *,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWModule * > > > *|sword::ModMap *|std::map< sword::SWBuf,sword::SWModule * > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__mapT_sword__SWBuf_sword__SWOptionFilter_p_std__lessT_sword__SWBuf_t_std__allocatorT_std__pairT_sword__SWBuf_const_sword__SWOptionFilter_p_t_t_t = {"_p_std__mapT_sword__SWBuf_sword__SWOptionFilter_p_std__lessT_sword__SWBuf_t_std__allocatorT_std__pairT_sword__SWBuf_const_sword__SWOptionFilter_p_t_t_t", "sword::OptionFilterMap *|std::map< sword::SWBuf,sword::SWOptionFilter *,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWOptionFilter * > > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__mapT_sword__SWBuf_sword__multimapwithdefaultT_sword__SWBuf_sword__SWBuf_std__lessT_sword__SWBuf_t_t_std__lessT_sword__SWBuf_t_std__allocatorT_std__pairT_sword__SWBuf_const_sword__multimapwithdefaultT_sword__SWBuf_sword__SWBuf_std__lessT_sword__SWBuf_t_t_t_t_t = {"_p_std__mapT_sword__SWBuf_sword__multimapwithdefaultT_sword__SWBuf_sword__SWBuf_std__lessT_sword__SWBuf_t_t_std__lessT_sword__SWBuf_t_std__allocatorT_std__pairT_sword__SWBuf_const_sword__multimapwithdefaultT_sword__SWBuf_sword__SWBuf_std__lessT_sword__SWBuf_t_t_t_t_t", "sword::SectionMap *|std::map< sword::SWBuf,sword::multimapwithdefault< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > >,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::multimapwithdefault< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > > > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__multimapT_sword__SWBuf_sword__SWBuf_std__lessT_sword__SWBuf_t_t = {"_p_std__multimapT_sword__SWBuf_sword__SWBuf_std__lessT_sword__SWBuf_t_t", "PyConfigEntMap *|std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > *|std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_sword__DirEntry_t = {"_p_std__vectorT_sword__DirEntry_t", "std::vector< sword::DirEntry,std::allocator< sword::DirEntry > > *|std::vector< sword::DirEntry > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_sword__SWBuf_t = {"_p_std__vectorT_sword__SWBuf_t", "std::vector< sword::SWBuf,std::allocator< sword::SWBuf > > *|std::vector< sword::SWBuf > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_swig__SwigPyIterator = {"_p_swig__SwigPyIterator", "swig::SwigPyIterator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_sword__BasicFilterUserData = {"_p_sword__BasicFilterUserData", "sword::BasicFilterUserData *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_sword__DirEntry = {"_p_sword__DirEntry", "std::vector< sword::DirEntry >::value_type *|sword::DirEntry *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_sword__EncodingFilterMgr = {"_p_sword__EncodingFilterMgr", "sword::EncodingFilterMgr *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_sword__FileDesc = {"_p_sword__FileDesc", "sword::FileDesc *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_sword__FileMgr = {"_p_sword__FileMgr", "sword::FileMgr *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_sword__GBFHTMLHREF = {"_p_sword__GBFHTMLHREF", "sword::GBFHTMLHREF *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_sword__InstallMgr = {"_p_sword__InstallMgr", "sword::InstallMgr *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_sword__InstallSource = {"_p_sword__InstallSource", "std::map< sword::SWBuf,sword::InstallSource * >::mapped_type|sword::InstallSource *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_sword__LZSSCompress = {"_p_sword__LZSSCompress", "sword::LZSSCompress *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_sword__ListKey = {"_p_sword__ListKey", "sword::ListKey *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_sword__LocaleMgr = {"_p_sword__LocaleMgr", "sword::LocaleMgr *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_sword__MarkupFilterMgr = {"_p_sword__MarkupFilterMgr", "sword::MarkupFilterMgr *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_sword__OSISHTMLHREF = {"_p_sword__OSISHTMLHREF", "sword::OSISHTMLHREF *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_sword__RawCom = {"_p_sword__RawCom", "sword::RawCom *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_sword__RawGenBook = {"_p_sword__RawGenBook", "sword::RawGenBook *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_sword__RawLD = {"_p_sword__RawLD", "sword::RawLD *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_sword__RawLD4 = {"_p_sword__RawLD4", "sword::RawLD4 *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_sword__RawStr = {"_p_sword__RawStr", "sword::RawStr *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_sword__RawStr4 = {"_p_sword__RawStr4", "sword::RawStr4 *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_sword__RawText = {"_p_sword__RawText", "sword::RawText *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_sword__RawVerse = {"_p_sword__RawVerse", "sword::RawVerse *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_sword__RemoteTransport = {"_p_sword__RemoteTransport", "sword::RemoteTransport *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_sword__SWBasicFilter = {"_p_sword__SWBasicFilter", "sword::SWBasicFilter *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_sword__SWBuf = {"_p_sword__SWBuf", "std::list< sword::SWBuf >::value_type *|std::map< sword::SWBuf,std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > >,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > > > > >::key_type *|std::map< sword::SWBuf,std::map< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf >,std::allocator< std::pair< sword::SWBuf const,sword::SWBuf > > > >::key_type *|std::map< sword::SWBuf,std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > >::key_type *|std::map< sword::SWBuf,sword::InstallSource * >::key_type *|std::map< sword::SWBuf,sword::SWBuf >::key_type *|std::map< sword::SWBuf,sword::SWBuf >::mapped_type *|std::map< sword::SWBuf,sword::SWModule * >::key_type *|std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > >::key_type *|std::multimap< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > >::mapped_type *|std::vector< sword::SWBuf >::value_type *|sword::SWBuf *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_sword__SWClass = {"_p_sword__SWClass", "sword::SWClass *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_sword__SWCom = {"_p_sword__SWCom", "sword::SWCom *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_sword__SWCompress = {"_p_sword__SWCompress", "sword::SWCompress *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_sword__SWConfig = {"_p_sword__SWConfig", "sword::SWConfig *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_sword__SWDisplay = {"_p_sword__SWDisplay", "sword::SWDisplay *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_sword__SWFilter = {"_p_sword__SWFilter", "sword::SWFilter *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_sword__SWFilterMgr = {"_p_sword__SWFilterMgr", "sword::SWFilterMgr *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_sword__SWGenBook = {"_p_sword__SWGenBook", "sword::SWGenBook *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_sword__SWKey = {"_p_sword__SWKey", "sword::SWKey *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_sword__SWLD = {"_p_sword__SWLD", "sword::SWLD *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_sword__SWLocale = {"_p_sword__SWLocale", "sword::SWLocale *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_sword__SWLog = {"_p_sword__SWLog", "sword::SWLog *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_sword__SWMgr = {"_p_sword__SWMgr", "sword::SWMgr *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_sword__SWModule = {"_p_sword__SWModule", "std::map< sword::SWBuf,sword::SWModule * >::mapped_type|sword::SWModule *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_sword__SWObject = {"_p_sword__SWObject", "sword::SWObject *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_sword__SWOptionFilter = {"_p_sword__SWOptionFilter", "sword::SWOptionFilter *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_sword__SWSearchable = {"_p_sword__SWSearchable", "sword::SWSearchable *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_sword__SWText = {"_p_sword__SWText", "sword::SWText *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_sword__SWVersion = {"_p_sword__SWVersion", "sword::SWVersion *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_sword__SW_POSITION = {"_p_sword__SW_POSITION", "sword::SW_POSITION *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_sword__StatusReporter = {"_p_sword__StatusReporter", "sword::StatusReporter *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_sword__StringMgr = {"_p_sword__StringMgr", "sword::StringMgr *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_sword__ThMLHTMLHREF = {"_p_sword__ThMLHTMLHREF", "sword::ThMLHTMLHREF *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_sword__TreeKey = {"_p_sword__TreeKey", "sword::TreeKey *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_sword__TreeKeyIdx = {"_p_sword__TreeKeyIdx", "sword::TreeKeyIdx *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_sword__TreeKey__PositionChangeListener = {"_p_sword__TreeKey__PositionChangeListener", "sword::TreeKey::PositionChangeListener *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_sword__URL = {"_p_sword__URL", "sword::URL *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_sword__UTF8HTML = {"_p_sword__UTF8HTML", "sword::UTF8HTML *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_sword__VerseKey = {"_p_sword__VerseKey", "sword::VerseKey *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_sword__VerseTreeKey = {"_p_sword__VerseTreeKey", "sword::VerseTreeKey *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_sword__VersificationMgr = {"_p_sword__VersificationMgr", "sword::VersificationMgr *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_sword__VersificationMgr__System = {"_p_sword__VersificationMgr__System", "sword::VersificationMgr::System *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_sword__XMLTag = {"_p_sword__XMLTag", "sword::XMLTag *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_sword__ZipCompress = {"_p_sword__ZipCompress", "sword::ZipCompress *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_sword__abbrev = {"_p_sword__abbrev", "sword::abbrev *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_sword__multimapwithdefaultT_sword__SWBuf_sword__SWBuf_std__lessT_sword__SWBuf_t_t = {"_p_sword__multimapwithdefaultT_sword__SWBuf_sword__SWBuf_std__lessT_sword__SWBuf_t_t", "sword::ConfigEntMap *|sword::multimapwithdefault< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_sword__multimapwithdefaultT_sword__SWBuf_sword__SWBuf_std__lessT_sword__SWBuf_t_t__iterator = {"_p_sword__multimapwithdefaultT_sword__SWBuf_sword__SWBuf_std__lessT_sword__SWBuf_t_t__iterator", "sword::ConfigEntMap::iterator *|sword::multimapwithdefault< sword::SWBuf,sword::SWBuf,std::less< sword::SWBuf > >::iterator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_sword__sbook = {"_p_sword__sbook", "sword::sbook *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_sword__zCom = {"_p_sword__zCom", "sword::zCom *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_sword__zLD = {"_p_sword__zLD", "sword::zLD *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_sword__zStr = {"_p_sword__zStr", "sword::zStr *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_sword__zText = {"_p_sword__zText", "sword::zText *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_sword__zVerse = {"_p_sword__zVerse", "sword::zVerse *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "unsigned char *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "unsigned long *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_unsigned_short = {"_p_unsigned_short", "unsigned short *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_value_type = {"_p_value_type", "value_type *", 0, 0, (void*)0, 0};

static swig_type_info *swig_type_initial[] = {
  &_swigt__p_MarkupCallback,
  &_swigt__p_MyMarkup,
  &_swigt__p_OSISData,
  &_swigt__p_ParameterMap,
  &_swigt__p_PyOSISHTMLHREF,
  &_swigt__p_PyStringMgr,
  &_swigt__p_PyThMLHTMLHREF,
  &_swigt__p_RenderCallback,
  &_swigt__p_ReturnSuccess,
  &_swigt__p_SWSearcher,
  &_swigt__p_SW_u16,
  &_swigt__p_SW_u32,
  &_swigt__p_ThMLData,
  &_swigt__p_allocator_type,
  &_swigt__p_char,
  &_swigt__p_difference_type,
  &_swigt__p_first_type,
  &_swigt__p_int,
  &_swigt__p_key_type,
  &_swigt__p_long,
  &_swigt__p_mapped_type,
  &_swigt__p_p_PyObject,
  &_swigt__p_p_char,
  &_swigt__p_second_type,
  &_swigt__p_size_type,
  &_swigt__p_std__allocatorT_std__pairT_sword__SWBuf_const_std__mapT_sword__SWBuf_AttributeValueMap_t_t_t,
  &_swigt__p_std__allocatorT_std__pairT_sword__SWBuf_const_std__mapT_sword__SWBuf_sword__SWBuf_t_t_t,
  &_swigt__p_std__allocatorT_std__pairT_sword__SWBuf_const_std__multimapT_sword__SWBuf_sword__SWBuf_std__lessT_sword__SWBuf_t_t_t_t,
  &_swigt__p_std__allocatorT_std__pairT_sword__SWBuf_const_sword__InstallSource_p_t_t,
  &_swigt__p_std__allocatorT_std__pairT_sword__SWBuf_const_sword__SWBuf_t_t,
  &_swigt__p_std__allocatorT_std__pairT_sword__SWBuf_const_sword__SWModule_p_t_t,
  &_swigt__p_std__allocatorT_sword__DirEntry_t,
  &_swigt__p_std__allocatorT_sword__SWBuf_t,
  &_swigt__p_std__invalid_argument,
  &_swigt__p_std__lessT_sword__SWBuf_t,
  &_swigt__p_std__listT_sword__SWBuf_t,
  &_swigt__p_std__listT_sword__SWFilter_p_std__allocatorT_sword__SWFilter_p_t_t,
  &_swigt__p_std__listT_sword__SWOptionFilter_p_std__allocatorT_sword__SWOptionFilter_p_t_t,
  &_swigt__p_std__mapT_sword__SWBuf_AttributeListMap_t,
  &_swigt__p_std__mapT_sword__SWBuf_AttributeValueMap_t,
  &_swigt__p_std__mapT_sword__SWBuf_std__multimapT_sword__SWBuf_sword__SWBuf_std__lessT_sword__SWBuf_t_t_t,
  &_swigt__p_std__mapT_sword__SWBuf_sword__InstallSource_p_t,
  &_swigt__p_std__mapT_sword__SWBuf_sword__SWBuf_t,
  &_swigt__p_std__mapT_sword__SWBuf_sword__SWFilter_p_std__lessT_sword__SWBuf_t_std__allocatorT_std__pairT_sword__SWBuf_const_sword__SWFilter_p_t_t_t,
  &_swigt__p_std__mapT_sword__SWBuf_sword__SWLocale_p_std__lessT_sword__SWBuf_t_std__allocatorT_std__pairT_sword__SWBuf_const_sword__SWLocale_p_t_t_t,
  &_swigt__p_std__mapT_sword__SWBuf_sword__SWModule_p_t,
  &_swigt__p_std__mapT_sword__SWBuf_sword__SWOptionFilter_p_std__lessT_sword__SWBuf_t_std__allocatorT_std__pairT_sword__SWBuf_const_sword__SWOptionFilter_p_t_t_t,
  &_swigt__p_std__mapT_sword__SWBuf_sword__multimapwithdefaultT_sword__SWBuf_sword__SWBuf_std__lessT_sword__SWBuf_t_t_std__lessT_sword__SWBuf_t_std__allocatorT_std__pairT_sword__SWBuf_const_sword__multimapwithdefaultT_sword__SWBuf_sword__SWBuf_std__lessT_sword__SWBuf_t_t_t_t_t,
  &_swigt__p_std__multimapT_sword__SWBuf_sword__SWBuf_std__lessT_sword__SWBuf_t_t,
  &_swigt__p_std__vectorT_sword__DirEntry_t,
  &_swigt__p_std__vectorT_sword__SWBuf_t,
  &_swigt__p_swig__SwigPyIterator,
  &_swigt__p_sword__BasicFilterUserData,
  &_swigt__p_sword__DirEntry,
  &_swigt__p_sword__EncodingFilterMgr,
  &_swigt__p_sword__FileDesc,
  &_swigt__p_sword__FileMgr,
  &_swigt__p_sword__GBFHTMLHREF,
  &_swigt__p_sword__InstallMgr,
  &_swigt__p_sword__InstallSource,
  &_swigt__p_sword__LZSSCompress,
  &_swigt__p_sword__ListKey,
  &_swigt__p_sword__LocaleMgr,
  &_swigt__p_sword__MarkupFilterMgr,
  &_swigt__p_sword__OSISHTMLHREF,
  &_swigt__p_sword__RawCom,
  &_swigt__p_sword__RawGenBook,
  &_swigt__p_sword__RawLD,
  &_swigt__p_sword__RawLD4,
  &_swigt__p_sword__RawStr,
  &_swigt__p_sword__RawStr4,
  &_swigt__p_sword__RawText,
  &_swigt__p_sword__RawVerse,
  &_swigt__p_sword__RemoteTransport,
  &_swigt__p_sword__SWBasicFilter,
  &_swigt__p_sword__SWBuf,
  &_swigt__p_sword__SWClass,
  &_swigt__p_sword__SWCom,
  &_swigt__p_sword__SWCompress,
  &_swigt__p_sword__SWConfig,
  &_swigt__p_sword__SWDisplay,
  &_swigt__p_sword__SWFilter,
  &_swigt__p_sword__SWFilterMgr,
  &_swigt__p_sword__SWGenBook,
  &_swigt__p_sword__SWKey,
  &_swigt__p_sword__SWLD,
  &_swigt__p_sword__SWLocale,
  &_swigt__p_sword__SWLog,
  &_swigt__p_sword__SWMgr,
  &_swigt__p_sword__SWModule,
  &_swigt__p_sword__SWObject,
  &_swigt__p_sword__SWOptionFilter,
  &_swigt__p_sword__SWSearchable,
  &_swigt__p_sword__SWText,
  &_swigt__p_sword__SWVersion,
  &_swigt__p_sword__SW_POSITION,
  &_swigt__p_sword__StatusReporter,
  &_swigt__p_sword__StringMgr,
  &_swigt__p_sword__ThMLHTMLHREF,
  &_swigt__p_sword__TreeKey,
  &_swigt__p_sword__TreeKeyIdx,
  &_swigt__p_sword__TreeKey__PositionChangeListener,
  &_swigt__p_sword__URL,
  &_swigt__p_sword__UTF8HTML,
  &_swigt__p_sword__VerseKey,
  &_swigt__p_sword__VerseTreeKey,
  &_swigt__p_sword__VersificationMgr,
  &_swigt__p_sword__VersificationMgr__System,
  &_swigt__p_sword__XMLTag,
  &_swigt__p_sword__ZipCompress,
  &_swigt__p_sword__abbrev,
  &_swigt__p_sword__multimapwithdefaultT_sword__SWBuf_sword__SWBuf_std__lessT_sword__SWBuf_t_t,
  &_swigt__p_sword__multimapwithdefaultT_sword__SWBuf_sword__SWBuf_std__lessT_sword__SWBuf_t_t__iterator,
  &_swigt__p_sword__sbook,
  &_swigt__p_sword__zCom,
  &_swigt__p_sword__zLD,
  &_swigt__p_sword__zStr,
  &_swigt__p_sword__zText,
  &_swigt__p_sword__zVerse,
  &_swigt__p_unsigned_char,
  &_swigt__p_unsigned_long,
  &_swigt__p_unsigned_short,
  &_swigt__p_value_type,
};

static swig_cast_info _swigc__p_MarkupCallback[] = {  {&_swigt__p_MarkupCallback, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_MyMarkup[] = {  {&_swigt__p_MyMarkup, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_OSISData[] = {  {&_swigt__p_OSISData, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ParameterMap[] = {  {&_swigt__p_ParameterMap, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_PyOSISHTMLHREF[] = {  {&_swigt__p_PyOSISHTMLHREF, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_PyStringMgr[] = {  {&_swigt__p_PyStringMgr, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_PyThMLHTMLHREF[] = {  {&_swigt__p_PyThMLHTMLHREF, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_RenderCallback[] = {  {&_swigt__p_RenderCallback, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ReturnSuccess[] = {  {&_swigt__p_ReturnSuccess, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SWSearcher[] = {  {&_swigt__p_SWSearcher, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SW_u16[] = {  {&_swigt__p_SW_u16, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SW_u32[] = {  {&_swigt__p_SW_u32, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ThMLData[] = {  {&_swigt__p_ThMLData, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_allocator_type[] = {  {&_swigt__p_allocator_type, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_char[] = {  {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_difference_type[] = {  {&_swigt__p_difference_type, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_first_type[] = {  {&_swigt__p_first_type, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_int[] = {  {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_key_type[] = {  {&_swigt__p_key_type, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_long[] = {  {&_swigt__p_long, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mapped_type[] = {  {&_swigt__p_mapped_type, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_PyObject[] = {  {&_swigt__p_p_PyObject, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_char[] = {  {&_swigt__p_p_char, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_second_type[] = {  {&_swigt__p_second_type, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_size_type[] = {  {&_swigt__p_size_type, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__allocatorT_std__pairT_sword__SWBuf_const_std__mapT_sword__SWBuf_AttributeValueMap_t_t_t[] = {  {&_swigt__p_std__allocatorT_std__pairT_sword__SWBuf_const_std__mapT_sword__SWBuf_AttributeValueMap_t_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__allocatorT_std__pairT_sword__SWBuf_const_std__mapT_sword__SWBuf_sword__SWBuf_t_t_t[] = {  {&_swigt__p_std__allocatorT_std__pairT_sword__SWBuf_const_std__mapT_sword__SWBuf_sword__SWBuf_t_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__allocatorT_std__pairT_sword__SWBuf_const_std__multimapT_sword__SWBuf_sword__SWBuf_std__lessT_sword__SWBuf_t_t_t_t[] = {  {&_swigt__p_std__allocatorT_std__pairT_sword__SWBuf_const_std__multimapT_sword__SWBuf_sword__SWBuf_std__lessT_sword__SWBuf_t_t_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__allocatorT_std__pairT_sword__SWBuf_const_sword__InstallSource_p_t_t[] = {  {&_swigt__p_std__allocatorT_std__pairT_sword__SWBuf_const_sword__InstallSource_p_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__allocatorT_std__pairT_sword__SWBuf_const_sword__SWBuf_t_t[] = {  {&_swigt__p_std__allocatorT_std__pairT_sword__SWBuf_const_sword__SWBuf_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__allocatorT_std__pairT_sword__SWBuf_const_sword__SWModule_p_t_t[] = {  {&_swigt__p_std__allocatorT_std__pairT_sword__SWBuf_const_sword__SWModule_p_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__allocatorT_sword__DirEntry_t[] = {  {&_swigt__p_std__allocatorT_sword__DirEntry_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__allocatorT_sword__SWBuf_t[] = {  {&_swigt__p_std__allocatorT_sword__SWBuf_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__invalid_argument[] = {  {&_swigt__p_std__invalid_argument, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__lessT_sword__SWBuf_t[] = {  {&_swigt__p_std__lessT_sword__SWBuf_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__listT_sword__SWBuf_t[] = {  {&_swigt__p_std__listT_sword__SWBuf_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__listT_sword__SWFilter_p_std__allocatorT_sword__SWFilter_p_t_t[] = {  {&_swigt__p_std__listT_sword__SWFilter_p_std__allocatorT_sword__SWFilter_p_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__listT_sword__SWOptionFilter_p_std__allocatorT_sword__SWOptionFilter_p_t_t[] = {  {&_swigt__p_std__listT_sword__SWOptionFilter_p_std__allocatorT_sword__SWOptionFilter_p_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__mapT_sword__SWBuf_AttributeListMap_t[] = {  {&_swigt__p_std__mapT_sword__SWBuf_AttributeListMap_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__mapT_sword__SWBuf_AttributeValueMap_t[] = {  {&_swigt__p_std__mapT_sword__SWBuf_AttributeValueMap_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__mapT_sword__SWBuf_std__multimapT_sword__SWBuf_sword__SWBuf_std__lessT_sword__SWBuf_t_t_t[] = {  {&_swigt__p_std__mapT_sword__SWBuf_std__multimapT_sword__SWBuf_sword__SWBuf_std__lessT_sword__SWBuf_t_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__mapT_sword__SWBuf_sword__InstallSource_p_t[] = {  {&_swigt__p_std__mapT_sword__SWBuf_sword__InstallSource_p_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__mapT_sword__SWBuf_sword__SWBuf_t[] = {  {&_swigt__p_std__mapT_sword__SWBuf_sword__SWBuf_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__mapT_sword__SWBuf_sword__SWFilter_p_std__lessT_sword__SWBuf_t_std__allocatorT_std__pairT_sword__SWBuf_const_sword__SWFilter_p_t_t_t[] = {  {&_swigt__p_std__mapT_sword__SWBuf_sword__SWFilter_p_std__lessT_sword__SWBuf_t_std__allocatorT_std__pairT_sword__SWBuf_const_sword__SWFilter_p_t_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__mapT_sword__SWBuf_sword__SWLocale_p_std__lessT_sword__SWBuf_t_std__allocatorT_std__pairT_sword__SWBuf_const_sword__SWLocale_p_t_t_t[] = {  {&_swigt__p_std__mapT_sword__SWBuf_sword__SWLocale_p_std__lessT_sword__SWBuf_t_std__allocatorT_std__pairT_sword__SWBuf_const_sword__SWLocale_p_t_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__mapT_sword__SWBuf_sword__SWModule_p_t[] = {  {&_swigt__p_std__mapT_sword__SWBuf_sword__SWModule_p_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__mapT_sword__SWBuf_sword__SWOptionFilter_p_std__lessT_sword__SWBuf_t_std__allocatorT_std__pairT_sword__SWBuf_const_sword__SWOptionFilter_p_t_t_t[] = {  {&_swigt__p_std__mapT_sword__SWBuf_sword__SWOptionFilter_p_std__lessT_sword__SWBuf_t_std__allocatorT_std__pairT_sword__SWBuf_const_sword__SWOptionFilter_p_t_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__mapT_sword__SWBuf_sword__multimapwithdefaultT_sword__SWBuf_sword__SWBuf_std__lessT_sword__SWBuf_t_t_std__lessT_sword__SWBuf_t_std__allocatorT_std__pairT_sword__SWBuf_const_sword__multimapwithdefaultT_sword__SWBuf_sword__SWBuf_std__lessT_sword__SWBuf_t_t_t_t_t[] = {  {&_swigt__p_std__mapT_sword__SWBuf_sword__multimapwithdefaultT_sword__SWBuf_sword__SWBuf_std__lessT_sword__SWBuf_t_t_std__lessT_sword__SWBuf_t_std__allocatorT_std__pairT_sword__SWBuf_const_sword__multimapwithdefaultT_sword__SWBuf_sword__SWBuf_std__lessT_sword__SWBuf_t_t_t_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__multimapT_sword__SWBuf_sword__SWBuf_std__lessT_sword__SWBuf_t_t[] = {  {&_swigt__p_std__multimapT_sword__SWBuf_sword__SWBuf_std__lessT_sword__SWBuf_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_sword__DirEntry_t[] = {  {&_swigt__p_std__vectorT_sword__DirEntry_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_sword__SWBuf_t[] = {  {&_swigt__p_std__vectorT_sword__SWBuf_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_swig__SwigPyIterator[] = {  {&_swigt__p_swig__SwigPyIterator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_sword__BasicFilterUserData[] = {  {&_swigt__p_sword__BasicFilterUserData, 0, 0, 0},  {&_swigt__p_OSISData, _p_OSISDataTo_p_sword__BasicFilterUserData, 0, 0},  {&_swigt__p_ThMLData, _p_ThMLDataTo_p_sword__BasicFilterUserData, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_sword__DirEntry[] = {  {&_swigt__p_sword__DirEntry, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_sword__EncodingFilterMgr[] = {  {&_swigt__p_sword__EncodingFilterMgr, 0, 0, 0},  {&_swigt__p_MyMarkup, _p_MyMarkupTo_p_sword__EncodingFilterMgr, 0, 0},  {&_swigt__p_sword__MarkupFilterMgr, _p_sword__MarkupFilterMgrTo_p_sword__EncodingFilterMgr, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_sword__FileDesc[] = {  {&_swigt__p_sword__FileDesc, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_sword__FileMgr[] = {  {&_swigt__p_sword__FileMgr, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_sword__GBFHTMLHREF[] = {  {&_swigt__p_sword__GBFHTMLHREF, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_sword__InstallMgr[] = {  {&_swigt__p_sword__InstallMgr, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_sword__InstallSource[] = {  {&_swigt__p_sword__InstallSource, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_sword__LZSSCompress[] = {  {&_swigt__p_sword__LZSSCompress, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_sword__ListKey[] = {  {&_swigt__p_sword__ListKey, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_sword__LocaleMgr[] = {  {&_swigt__p_sword__LocaleMgr, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_sword__MarkupFilterMgr[] = {  {&_swigt__p_sword__MarkupFilterMgr, 0, 0, 0},  {&_swigt__p_MyMarkup, _p_MyMarkupTo_p_sword__MarkupFilterMgr, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_sword__OSISHTMLHREF[] = {  {&_swigt__p_sword__OSISHTMLHREF, 0, 0, 0},  {&_swigt__p_PyOSISHTMLHREF, _p_PyOSISHTMLHREFTo_p_sword__OSISHTMLHREF, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_sword__RawCom[] = {  {&_swigt__p_sword__RawCom, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_sword__RawGenBook[] = {  {&_swigt__p_sword__RawGenBook, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_sword__RawLD[] = {  {&_swigt__p_sword__RawLD, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_sword__RawLD4[] = {  {&_swigt__p_sword__RawLD4, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_sword__RawStr[] = {  {&_swigt__p_sword__RawStr, 0, 0, 0},  {&_swigt__p_sword__RawLD, _p_sword__RawLDTo_p_sword__RawStr, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_sword__RawStr4[] = {  {&_swigt__p_sword__RawStr4, 0, 0, 0},  {&_swigt__p_sword__RawLD4, _p_sword__RawLD4To_p_sword__RawStr4, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_sword__RawText[] = {  {&_swigt__p_sword__RawText, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_sword__RawVerse[] = {  {&_swigt__p_sword__RawVerse, 0, 0, 0},  {&_swigt__p_sword__RawCom, _p_sword__RawComTo_p_sword__RawVerse, 0, 0},  {&_swigt__p_sword__RawText, _p_sword__RawTextTo_p_sword__RawVerse, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_sword__RemoteTransport[] = {  {&_swigt__p_sword__RemoteTransport, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_sword__SWBasicFilter[] = {  {&_swigt__p_sword__SWBasicFilter, 0, 0, 0},  {&_swigt__p_PyOSISHTMLHREF, _p_PyOSISHTMLHREFTo_p_sword__SWBasicFilter, 0, 0},  {&_swigt__p_PyThMLHTMLHREF, _p_PyThMLHTMLHREFTo_p_sword__SWBasicFilter, 0, 0},  {&_swigt__p_sword__GBFHTMLHREF, _p_sword__GBFHTMLHREFTo_p_sword__SWBasicFilter, 0, 0},  {&_swigt__p_sword__OSISHTMLHREF, _p_sword__OSISHTMLHREFTo_p_sword__SWBasicFilter, 0, 0},  {&_swigt__p_sword__ThMLHTMLHREF, _p_sword__ThMLHTMLHREFTo_p_sword__SWBasicFilter, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_sword__SWBuf[] = {  {&_swigt__p_sword__SWBuf, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_sword__SWClass[] = {  {&_swigt__p_sword__SWClass, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_sword__SWCom[] = {  {&_swigt__p_sword__SWCom, 0, 0, 0},  {&_swigt__p_sword__RawCom, _p_sword__RawComTo_p_sword__SWCom, 0, 0},  {&_swigt__p_sword__zCom, _p_sword__zComTo_p_sword__SWCom, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_sword__SWCompress[] = {  {&_swigt__p_sword__SWCompress, 0, 0, 0},  {&_swigt__p_sword__LZSSCompress, _p_sword__LZSSCompressTo_p_sword__SWCompress, 0, 0},  {&_swigt__p_sword__ZipCompress, _p_sword__ZipCompressTo_p_sword__SWCompress, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_sword__SWConfig[] = {  {&_swigt__p_sword__SWConfig, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_sword__SWDisplay[] = {  {&_swigt__p_sword__SWDisplay, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_sword__SWFilter[] = {  {&_swigt__p_sword__SWFilter, 0, 0, 0},  {&_swigt__p_PyOSISHTMLHREF, _p_PyOSISHTMLHREFTo_p_sword__SWFilter, 0, 0},  {&_swigt__p_PyThMLHTMLHREF, _p_PyThMLHTMLHREFTo_p_sword__SWFilter, 0, 0},  {&_swigt__p_sword__GBFHTMLHREF, _p_sword__GBFHTMLHREFTo_p_sword__SWFilter, 0, 0},  {&_swigt__p_sword__OSISHTMLHREF, _p_sword__OSISHTMLHREFTo_p_sword__SWFilter, 0, 0},  {&_swigt__p_sword__SWBasicFilter, _p_sword__SWBasicFilterTo_p_sword__SWFilter, 0, 0},  {&_swigt__p_sword__SWOptionFilter, _p_sword__SWOptionFilterTo_p_sword__SWFilter, 0, 0},  {&_swigt__p_sword__ThMLHTMLHREF, _p_sword__ThMLHTMLHREFTo_p_sword__SWFilter, 0, 0},  {&_swigt__p_sword__UTF8HTML, _p_sword__UTF8HTMLTo_p_sword__SWFilter, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_sword__SWFilterMgr[] = {  {&_swigt__p_sword__SWFilterMgr, 0, 0, 0},  {&_swigt__p_MyMarkup, _p_MyMarkupTo_p_sword__SWFilterMgr, 0, 0},  {&_swigt__p_sword__EncodingFilterMgr, _p_sword__EncodingFilterMgrTo_p_sword__SWFilterMgr, 0, 0},  {&_swigt__p_sword__MarkupFilterMgr, _p_sword__MarkupFilterMgrTo_p_sword__SWFilterMgr, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_sword__SWGenBook[] = {  {&_swigt__p_sword__SWGenBook, 0, 0, 0},  {&_swigt__p_sword__RawGenBook, _p_sword__RawGenBookTo_p_sword__SWGenBook, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_sword__SWKey[] = {  {&_swigt__p_sword__SWKey, 0, 0, 0},  {&_swigt__p_sword__ListKey, _p_sword__ListKeyTo_p_sword__SWKey, 0, 0},  {&_swigt__p_sword__TreeKey, _p_sword__TreeKeyTo_p_sword__SWKey, 0, 0},  {&_swigt__p_sword__TreeKeyIdx, _p_sword__TreeKeyIdxTo_p_sword__SWKey, 0, 0},  {&_swigt__p_sword__VerseKey, _p_sword__VerseKeyTo_p_sword__SWKey, 0, 0},  {&_swigt__p_sword__VerseTreeKey, _p_sword__VerseTreeKeyTo_p_sword__SWKey, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_sword__SWLD[] = {  {&_swigt__p_sword__SWLD, 0, 0, 0},  {&_swigt__p_sword__RawLD, _p_sword__RawLDTo_p_sword__SWLD, 0, 0},  {&_swigt__p_sword__RawLD4, _p_sword__RawLD4To_p_sword__SWLD, 0, 0},  {&_swigt__p_sword__zLD, _p_sword__zLDTo_p_sword__SWLD, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_sword__SWLocale[] = {  {&_swigt__p_sword__SWLocale, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_sword__SWLog[] = {  {&_swigt__p_sword__SWLog, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_sword__SWMgr[] = {  {&_swigt__p_sword__SWMgr, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_sword__SWModule[] = {  {&_swigt__p_sword__SWModule, 0, 0, 0},  {&_swigt__p_sword__RawCom, _p_sword__RawComTo_p_sword__SWModule, 0, 0},  {&_swigt__p_sword__RawGenBook, _p_sword__RawGenBookTo_p_sword__SWModule, 0, 0},  {&_swigt__p_sword__RawLD, _p_sword__RawLDTo_p_sword__SWModule, 0, 0},  {&_swigt__p_sword__RawLD4, _p_sword__RawLD4To_p_sword__SWModule, 0, 0},  {&_swigt__p_sword__RawText, _p_sword__RawTextTo_p_sword__SWModule, 0, 0},  {&_swigt__p_sword__SWCom, _p_sword__SWComTo_p_sword__SWModule, 0, 0},  {&_swigt__p_sword__SWGenBook, _p_sword__SWGenBookTo_p_sword__SWModule, 0, 0},  {&_swigt__p_sword__SWLD, _p_sword__SWLDTo_p_sword__SWModule, 0, 0},  {&_swigt__p_sword__SWText, _p_sword__SWTextTo_p_sword__SWModule, 0, 0},  {&_swigt__p_sword__zCom, _p_sword__zComTo_p_sword__SWModule, 0, 0},  {&_swigt__p_sword__zLD, _p_sword__zLDTo_p_sword__SWModule, 0, 0},  {&_swigt__p_sword__zText, _p_sword__zTextTo_p_sword__SWModule, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_sword__SWObject[] = {  {&_swigt__p_sword__SWObject, 0, 0, 0},  {&_swigt__p_sword__ListKey, _p_sword__ListKeyTo_p_sword__SWObject, 0, 0},  {&_swigt__p_sword__SWDisplay, _p_sword__SWDisplayTo_p_sword__SWObject, 0, 0},  {&_swigt__p_sword__SWKey, _p_sword__SWKeyTo_p_sword__SWObject, 0, 0},  {&_swigt__p_sword__TreeKey, _p_sword__TreeKeyTo_p_sword__SWObject, 0, 0},  {&_swigt__p_sword__TreeKeyIdx, _p_sword__TreeKeyIdxTo_p_sword__SWObject, 0, 0},  {&_swigt__p_sword__VerseKey, _p_sword__VerseKeyTo_p_sword__SWObject, 0, 0},  {&_swigt__p_sword__VerseTreeKey, _p_sword__VerseTreeKeyTo_p_sword__SWObject, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_sword__SWOptionFilter[] = {  {&_swigt__p_sword__SWOptionFilter, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_sword__SWSearchable[] = {  {&_swigt__p_sword__SWSearchable, 0, 0, 0},  {&_swigt__p_sword__RawCom, _p_sword__RawComTo_p_sword__SWSearchable, 0, 0},  {&_swigt__p_sword__RawGenBook, _p_sword__RawGenBookTo_p_sword__SWSearchable, 0, 0},  {&_swigt__p_sword__RawLD, _p_sword__RawLDTo_p_sword__SWSearchable, 0, 0},  {&_swigt__p_sword__RawLD4, _p_sword__RawLD4To_p_sword__SWSearchable, 0, 0},  {&_swigt__p_sword__RawText, _p_sword__RawTextTo_p_sword__SWSearchable, 0, 0},  {&_swigt__p_sword__SWCom, _p_sword__SWComTo_p_sword__SWSearchable, 0, 0},  {&_swigt__p_sword__SWGenBook, _p_sword__SWGenBookTo_p_sword__SWSearchable, 0, 0},  {&_swigt__p_sword__SWLD, _p_sword__SWLDTo_p_sword__SWSearchable, 0, 0},  {&_swigt__p_sword__SWModule, _p_sword__SWModuleTo_p_sword__SWSearchable, 0, 0},  {&_swigt__p_sword__SWText, _p_sword__SWTextTo_p_sword__SWSearchable, 0, 0},  {&_swigt__p_sword__zCom, _p_sword__zComTo_p_sword__SWSearchable, 0, 0},  {&_swigt__p_sword__zLD, _p_sword__zLDTo_p_sword__SWSearchable, 0, 0},  {&_swigt__p_sword__zText, _p_sword__zTextTo_p_sword__SWSearchable, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_sword__SWText[] = {  {&_swigt__p_sword__SWText, 0, 0, 0},  {&_swigt__p_sword__RawText, _p_sword__RawTextTo_p_sword__SWText, 0, 0},  {&_swigt__p_sword__zText, _p_sword__zTextTo_p_sword__SWText, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_sword__SWVersion[] = {  {&_swigt__p_sword__SWVersion, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_sword__SW_POSITION[] = {  {&_swigt__p_sword__SW_POSITION, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_sword__StatusReporter[] = {  {&_swigt__p_sword__StatusReporter, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_sword__StringMgr[] = {  {&_swigt__p_sword__StringMgr, 0, 0, 0},  {&_swigt__p_PyStringMgr, _p_PyStringMgrTo_p_sword__StringMgr, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_sword__ThMLHTMLHREF[] = {  {&_swigt__p_sword__ThMLHTMLHREF, 0, 0, 0},  {&_swigt__p_PyThMLHTMLHREF, _p_PyThMLHTMLHREFTo_p_sword__ThMLHTMLHREF, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_sword__TreeKey[] = {  {&_swigt__p_sword__TreeKey, 0, 0, 0},  {&_swigt__p_sword__TreeKeyIdx, _p_sword__TreeKeyIdxTo_p_sword__TreeKey, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_sword__TreeKeyIdx[] = {  {&_swigt__p_sword__TreeKeyIdx, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_sword__TreeKey__PositionChangeListener[] = {  {&_swigt__p_sword__TreeKey__PositionChangeListener, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_sword__URL[] = {  {&_swigt__p_sword__URL, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_sword__UTF8HTML[] = {  {&_swigt__p_sword__UTF8HTML, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_sword__VerseKey[] = {  {&_swigt__p_sword__VerseKey, 0, 0, 0},  {&_swigt__p_sword__VerseTreeKey, _p_sword__VerseTreeKeyTo_p_sword__VerseKey, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_sword__VerseTreeKey[] = {  {&_swigt__p_sword__VerseTreeKey, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_sword__VersificationMgr[] = {  {&_swigt__p_sword__VersificationMgr, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_sword__VersificationMgr__System[] = {  {&_swigt__p_sword__VersificationMgr__System, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_sword__XMLTag[] = {  {&_swigt__p_sword__XMLTag, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_sword__ZipCompress[] = {  {&_swigt__p_sword__ZipCompress, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_sword__abbrev[] = {  {&_swigt__p_sword__abbrev, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_sword__multimapwithdefaultT_sword__SWBuf_sword__SWBuf_std__lessT_sword__SWBuf_t_t[] = {  {&_swigt__p_sword__multimapwithdefaultT_sword__SWBuf_sword__SWBuf_std__lessT_sword__SWBuf_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_sword__multimapwithdefaultT_sword__SWBuf_sword__SWBuf_std__lessT_sword__SWBuf_t_t__iterator[] = {  {&_swigt__p_sword__multimapwithdefaultT_sword__SWBuf_sword__SWBuf_std__lessT_sword__SWBuf_t_t__iterator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_sword__sbook[] = {  {&_swigt__p_sword__sbook, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_sword__zCom[] = {  {&_swigt__p_sword__zCom, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_sword__zLD[] = {  {&_swigt__p_sword__zLD, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_sword__zStr[] = {  {&_swigt__p_sword__zStr, 0, 0, 0},  {&_swigt__p_sword__zLD, _p_sword__zLDTo_p_sword__zStr, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_sword__zText[] = {  {&_swigt__p_sword__zText, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_sword__zVerse[] = {  {&_swigt__p_sword__zVerse, 0, 0, 0},  {&_swigt__p_sword__zCom, _p_sword__zComTo_p_sword__zVerse, 0, 0},  {&_swigt__p_sword__zText, _p_sword__zTextTo_p_sword__zVerse, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_unsigned_char[] = {  {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_unsigned_long[] = {  {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_unsigned_short[] = {  {&_swigt__p_unsigned_short, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_value_type[] = {  {&_swigt__p_value_type, 0, 0, 0},{0, 0, 0, 0}};

static swig_cast_info *swig_cast_initial[] = {
  _swigc__p_MarkupCallback,
  _swigc__p_MyMarkup,
  _swigc__p_OSISData,
  _swigc__p_ParameterMap,
  _swigc__p_PyOSISHTMLHREF,
  _swigc__p_PyStringMgr,
  _swigc__p_PyThMLHTMLHREF,
  _swigc__p_RenderCallback,
  _swigc__p_ReturnSuccess,
  _swigc__p_SWSearcher,
  _swigc__p_SW_u16,
  _swigc__p_SW_u32,
  _swigc__p_ThMLData,
  _swigc__p_allocator_type,
  _swigc__p_char,
  _swigc__p_difference_type,
  _swigc__p_first_type,
  _swigc__p_int,
  _swigc__p_key_type,
  _swigc__p_long,
  _swigc__p_mapped_type,
  _swigc__p_p_PyObject,
  _swigc__p_p_char,
  _swigc__p_second_type,
  _swigc__p_size_type,
  _swigc__p_std__allocatorT_std__pairT_sword__SWBuf_const_std__mapT_sword__SWBuf_AttributeValueMap_t_t_t,
  _swigc__p_std__allocatorT_std__pairT_sword__SWBuf_const_std__mapT_sword__SWBuf_sword__SWBuf_t_t_t,
  _swigc__p_std__allocatorT_std__pairT_sword__SWBuf_const_std__multimapT_sword__SWBuf_sword__SWBuf_std__lessT_sword__SWBuf_t_t_t_t,
  _swigc__p_std__allocatorT_std__pairT_sword__SWBuf_const_sword__InstallSource_p_t_t,
  _swigc__p_std__allocatorT_std__pairT_sword__SWBuf_const_sword__SWBuf_t_t,
  _swigc__p_std__allocatorT_std__pairT_sword__SWBuf_const_sword__SWModule_p_t_t,
  _swigc__p_std__allocatorT_sword__DirEntry_t,
  _swigc__p_std__allocatorT_sword__SWBuf_t,
  _swigc__p_std__invalid_argument,
  _swigc__p_std__lessT_sword__SWBuf_t,
  _swigc__p_std__listT_sword__SWBuf_t,
  _swigc__p_std__listT_sword__SWFilter_p_std__allocatorT_sword__SWFilter_p_t_t,
  _swigc__p_std__listT_sword__SWOptionFilter_p_std__allocatorT_sword__SWOptionFilter_p_t_t,
  _swigc__p_std__mapT_sword__SWBuf_AttributeListMap_t,
  _swigc__p_std__mapT_sword__SWBuf_AttributeValueMap_t,
  _swigc__p_std__mapT_sword__SWBuf_std__multimapT_sword__SWBuf_sword__SWBuf_std__lessT_sword__SWBuf_t_t_t,
  _swigc__p_std__mapT_sword__SWBuf_sword__InstallSource_p_t,
  _swigc__p_std__mapT_sword__SWBuf_sword__SWBuf_t,
  _swigc__p_std__mapT_sword__SWBuf_sword__SWFilter_p_std__lessT_sword__SWBuf_t_std__allocatorT_std__pairT_sword__SWBuf_const_sword__SWFilter_p_t_t_t,
  _swigc__p_std__mapT_sword__SWBuf_sword__SWLocale_p_std__lessT_sword__SWBuf_t_std__allocatorT_std__pairT_sword__SWBuf_const_sword__SWLocale_p_t_t_t,
  _swigc__p_std__mapT_sword__SWBuf_sword__SWModule_p_t,
  _swigc__p_std__mapT_sword__SWBuf_sword__SWOptionFilter_p_std__lessT_sword__SWBuf_t_std__allocatorT_std__pairT_sword__SWBuf_const_sword__SWOptionFilter_p_t_t_t,
  _swigc__p_std__mapT_sword__SWBuf_sword__multimapwithdefaultT_sword__SWBuf_sword__SWBuf_std__lessT_sword__SWBuf_t_t_std__lessT_sword__SWBuf_t_std__allocatorT_std__pairT_sword__SWBuf_const_sword__multimapwithdefaultT_sword__SWBuf_sword__SWBuf_std__lessT_sword__SWBuf_t_t_t_t_t,
  _swigc__p_std__multimapT_sword__SWBuf_sword__SWBuf_std__lessT_sword__SWBuf_t_t,
  _swigc__p_std__vectorT_sword__DirEntry_t,
  _swigc__p_std__vectorT_sword__SWBuf_t,
  _swigc__p_swig__SwigPyIterator,
  _swigc__p_sword__BasicFilterUserData,
  _swigc__p_sword__DirEntry,
  _swigc__p_sword__EncodingFilterMgr,
  _swigc__p_sword__FileDesc,
  _swigc__p_sword__FileMgr,
  _swigc__p_sword__GBFHTMLHREF,
  _swigc__p_sword__InstallMgr,
  _swigc__p_sword__InstallSource,
  _swigc__p_sword__LZSSCompress,
  _swigc__p_sword__ListKey,
  _swigc__p_sword__LocaleMgr,
  _swigc__p_sword__MarkupFilterMgr,
  _swigc__p_sword__OSISHTMLHREF,
  _swigc__p_sword__RawCom,
  _swigc__p_sword__RawGenBook,
  _swigc__p_sword__RawLD,
  _swigc__p_sword__RawLD4,
  _swigc__p_sword__RawStr,
  _swigc__p_sword__RawStr4,
  _swigc__p_sword__RawText,
  _swigc__p_sword__RawVerse,
  _swigc__p_sword__RemoteTransport,
  _swigc__p_sword__SWBasicFilter,
  _swigc__p_sword__SWBuf,
  _swigc__p_sword__SWClass,
  _swigc__p_sword__SWCom,
  _swigc__p_sword__SWCompress,
  _swigc__p_sword__SWConfig,
  _swigc__p_sword__SWDisplay,
  _swigc__p_sword__SWFilter,
  _swigc__p_sword__SWFilterMgr,
  _swigc__p_sword__SWGenBook,
  _swigc__p_sword__SWKey,
  _swigc__p_sword__SWLD,
  _swigc__p_sword__SWLocale,
  _swigc__p_sword__SWLog,
  _swigc__p_sword__SWMgr,
  _swigc__p_sword__SWModule,
  _swigc__p_sword__SWObject,
  _swigc__p_sword__SWOptionFilter,
  _swigc__p_sword__SWSearchable,
  _swigc__p_sword__SWText,
  _swigc__p_sword__SWVersion,
  _swigc__p_sword__SW_POSITION,
  _swigc__p_sword__StatusReporter,
  _swigc__p_sword__StringMgr,
  _swigc__p_sword__ThMLHTMLHREF,
  _swigc__p_sword__TreeKey,
  _swigc__p_sword__TreeKeyIdx,
  _swigc__p_sword__TreeKey__PositionChangeListener,
  _swigc__p_sword__URL,
  _swigc__p_sword__UTF8HTML,
  _swigc__p_sword__VerseKey,
  _swigc__p_sword__VerseTreeKey,
  _swigc__p_sword__VersificationMgr,
  _swigc__p_sword__VersificationMgr__System,
  _swigc__p_sword__XMLTag,
  _swigc__p_sword__ZipCompress,
  _swigc__p_sword__abbrev,
  _swigc__p_sword__multimapwithdefaultT_sword__SWBuf_sword__SWBuf_std__lessT_sword__SWBuf_t_t,
  _swigc__p_sword__multimapwithdefaultT_sword__SWBuf_sword__SWBuf_std__lessT_sword__SWBuf_t_t__iterator,
  _swigc__p_sword__sbook,
  _swigc__p_sword__zCom,
  _swigc__p_sword__zLD,
  _swigc__p_sword__zStr,
  _swigc__p_sword__zText,
  _swigc__p_sword__zVerse,
  _swigc__p_unsigned_char,
  _swigc__p_unsigned_long,
  _swigc__p_unsigned_short,
  _swigc__p_value_type,
};


/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */

static swig_const_info swig_const_table[] = {
{0, 0, 0, 0.0, 0, 0}};

#ifdef __cplusplus
}
#endif
/* -----------------------------------------------------------------------------
 * Type initialization:
 * This problem is made tough by the requirement that no dynamic
 * memory is used. Also, since swig_type_info structures store pointers to
 * swig_cast_info structures and swig_cast_info structures store pointers back
 * to swig_type_info structures, we need some lookup code at initialization.
 * The idea is that swig generates all the structures that are needed.
 * The runtime then collects these partially filled structures.
 * The SWIG_InitializeModule function takes these initial arrays out of
 * swig_module, and does all the lookup, filling in the swig_module.types
 * array with the correct data and linking the correct swig_cast_info
 * structures together.
 *
 * The generated swig_type_info structures are assigned statically to an initial
 * array. We just loop through that array, and handle each type individually.
 * First we lookup if this type has been already loaded, and if so, use the
 * loaded structure instead of the generated one. Then we have to fill in the
 * cast dependencies. The cast data is initially stored in something like a
 * two-dimensional array. Each row corresponds to a type (there are the same
 * number of rows as there are in the swig_type_initial array). Each entry in
 * a column is one of the swig_cast_info structures for that type.
 * The cast_initial array is actually an array of arrays, because each row has
 * a variable number of columns.
 *
 * We loop through the cast[] array associated with the type and mark casts
 * which have not been defined in previously loaded modules by assigning
 * cast pointer value to cast->next. We also hash cast->type->name string
 * and store the value in the cast->value field. If we encounter swig_cast_info
 * structure that represents a cast to self we move it to the beginning
 * of the cast array. One trick we need to do is making sure the type pointer
 * in the swig_cast_info struct is correct.
 *
 * First off, we lookup the cast->type name to see if it is already loaded.
 * There are three cases to handle:
 *  1) If the cast->type has already been loaded AND the type we are adding
 *     casting info to has not been loaded (it is in this module), THEN we
 *     replace the cast->type pointer with the type pointer that has already
 *     been loaded.
 *  2) If BOTH types (the one we are adding casting info to, and the
 *     cast->type) are loaded, THEN the cast info has already been loaded by
 *     the previous module so we just ignore it.
 *  3) Finally, if cast->type has not already been loaded, then we add that
 *     swig_cast_info to the list (because the cast->type) pointer will
 *     be correct.
 *
 * Once the cast array has been set up AND it does have new casts that need
 * to be added we sort non-self cast entries to move filtered out entries
 * to the end of the array and to arrange the rest in the increasing order
 * of their type pointer values. We store the index of the last added entry
 * in the cast->value field of the entry[0] (overwriting the name hash). Then
 * we sort <next|value> fields of the remaining entries to arrange hash values
 * in the increasing order. This way cast->next->type->name field matches
 * the cast->value hash.
 *
 * Example:
 * Array of casts for type stored at 0x5000, cast to type stored at 0x3000
 * has already been loaded
 *
 *      After sweep-and-hash:   After sort-by-type:    After sort-by-hash:
 *        ________________       ________________       ________________
 *       |                |     |                |     |                |
 * Entry |  type = 0x5000 |     |  type = 0x5000 |     |  type = 0x5000 |
 *   0   |                |     |                |     |                |
 *       |  next = Entry0 |     |  next = Entry0 |     |  next = Entry0 |
 *       | value = 1212   |     | value = 3      |     | value = 3      |
 *       |                |     |                |     |                |
 *       |================|     |================|     |================|
 *       |                |     |                |     |                |
 * Entry |  type = 0x2000 |     |  type = 0x1000 |     |  type = 0x1000 |
 *   1   |                |     |                |     |                |
 *       |  next = Entry1 |     |  next = Entry1 |     |  next = Entry3 |
 *       | value = 3434   |     | value = 4545   |     | value = 2323   |
 *       |________________|     |________________|     |________________|
 *       |                |     |                |     |                |
 * Entry |  type = 0x3000 |     |  type = 0x2000 |     |  type = 0x2000 |
 *   2   |                |     |                |     |                |
 *       |  next = 0      |     |  next = Entry2 |     |  next = Entry2 |
 *       | value = 0      |     | value = 3434   |     | value = 3434   |
 *       |________________|     |________________|     |________________|
 *       |                |     |                |     |                |
 * Entry |  type = 0x1000 |     |  type = 0x4000 |     |  type = 0x4000 |
 *   3   |                |     |                |     |                |
 *       |  next = Entry3 |     |  next = Entry3 |     |  next = Entry1 |
 *       | value = 4545   |     | value = 2323   |     | value = 4545   |
 *       |________________|     |________________|     |________________|
 *       |                |     |                |     |                |
 * Entry |  type = 0x4000 |     |  type = 0x3000 |     |  type = 0x3000 |
 *   4   |                |     |                |     |                |
 *       |  next = Entry4 |     |  next = 0      |     |  next = 0      |
 *       | value = 2323   |     | value = 0      |     | value = 0      |
 *       |________________|     |________________|     |________________|
 *
 * Once the cast array has been initialized, we use cast[0]->next field to link
 * it into the list of cast arrays for the type.
 *              ____    ____    ____
 * type->cast->|next|->|next|->|next|->0
 *             |----|  |----|  |----|
 *             |----|  |----|  |----|
 *             |----|  |----|  |----|
 *
 * Subsequent cast resolution works as follows:
 *
 * 1. Check whether the type matches the first entry in the current cast array.
 * 2. If not, then do a binary search over the (0:cast->value] interval using
 *    either type address or the hash value of the type name.
 * 3. If not found, then move over to the next cast array (cast[0]->next).
 *
 * ----------------------------------------------------------------------------- */

#ifdef __cplusplus
extern "C" {
#if 0
} /* c-mode */
#endif
#endif

#if 0
#define SWIGRUNTIME_DEBUG
#endif

#ifndef SWIG_INIT_CLIENT_DATA_TYPE
#define SWIG_INIT_CLIENT_DATA_TYPE void *
#endif

/*
 * Sort function that puts cast entries with nonzero 'next' at the front
 * of the array while ordering them by addresses of their 'type' structs.
 */
SWIGINTERN int SWIG_CastCmpStruct(const void *pa, const void *pb) {
  swig_cast_info *pca = (swig_cast_info *)pa;
  swig_cast_info *pcb = (swig_cast_info *)pb;
  if (pca->type < pcb->type)
  return (pca->next || pcb->next == 0) ? -1 : 1;
  if (pca->type > pcb->type)
  return (pcb->next || pca->next == 0) ? 1 : -1;
  return 0;
}

/*
 * Shell-sort 'next' and 'value' field pairs to order them by 'value'.
 */
SWIGINTERN void SWIG_CastHashSort(swig_cast_info *cast, int size) {
  const int hmax = size/9;
  int h, i;
  for(h = 1; h <= hmax; h = 3*h+1);
  for(; h > 0; h /= 3)
  {
    for(i = h; i < size; ++i)
    {
      swig_cast_info *p = cast[i].next;
      unsigned int hash = cast[i].value;
      int j = i;
      while(j >= h && hash < cast[j-h].value)
      {
        cast[j].next = cast[j-h].next;
        cast[j].value = cast[j-h].value;
        j -= h;
      }
      cast[j].next = p;
      cast[j].value = hash;
    }
  }
}

SWIGRUNTIME void
SWIG_InitializeModule(SWIG_INIT_CLIENT_DATA_TYPE clientdata) {
  size_t i;
  swig_module_info *module_head, *iter;
  int init;
  
  /* check to see if the circular list has been setup, if not, set it up */
  if (swig_module.next==0) {
    /* Initialize the swig_module */
    swig_module.type_initial = swig_type_initial;
    swig_module.cast_initial = swig_cast_initial;
    swig_module.next = &swig_module;
    init = 1;
  } else {
    init = 0;
  }
  
  /* Try and load any already created modules */
  module_head = SWIG_GetModule(clientdata);
  if (!module_head) {
    /* This is the first module loaded for this interpreter */
    /* so set the swig module into the interpreter */
    SWIG_SetModule(clientdata, &swig_module);
  } else {
    /* the interpreter has loaded a SWIG module, but has it loaded this one? */
    iter=module_head;
    do {
      if (iter==&swig_module) {
        /* Our module is already in the list, so there's nothing more to do. */
        return;
      }
      iter=iter->next;
    } while (iter!= module_head);
    
    /* otherwise we must add our module into the list */
    swig_module.next = module_head->next;
    module_head->next = &swig_module;
  }
  
  /* When multiple interpreters are used, a module could have already been initialized in
       a different interpreter, but not yet have a pointer in this interpreter.
       In this case, we do not want to continue adding types... everything should be
       set up already */
  if (init == 0) return;
  
  /* Now work on filling in swig_module.types */
#ifdef SWIGRUNTIME_DEBUG
  printf("SWIG_InitializeModule: size %lu\n", (unsigned long)swig_module.size);
#endif
  for (i = 0; i < swig_module.size; ++i) {
    swig_type_info *type = 0;
    swig_type_info *target_type;
    swig_cast_info *cast, *first;
    int num_mapped = 0;
    
#ifdef SWIGRUNTIME_DEBUG
    printf("SWIG_InitializeModule: type %lu %s\n", (unsigned long)i, swig_module.type_initial[i]->name);
#endif
    
    /* if there is another module already loaded */
    if (swig_module.next != &swig_module) {
      type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
    }
    if (type) {
      /* Overwrite clientdata field */
#ifdef SWIGRUNTIME_DEBUG
      printf("SWIG_InitializeModule: found type %s\n", type->name);
#endif
      if (swig_module.type_initial[i]->clientdata) {
        type->clientdata = swig_module.type_initial[i]->clientdata;
#ifdef SWIGRUNTIME_DEBUG
        printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
#endif
      }
    } else {
      type = swig_module.type_initial[i];
    }
    
    /* Insert casting types */
    cast = first = swig_module.cast_initial[i];
    while (cast->type) {
      /* Don't need to add information already in the list */
      target_type = 0;
#ifdef SWIGRUNTIME_DEBUG
      printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
#endif
      if (swig_module.next != &swig_module) {
        target_type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
        if (target_type) {
          /* Target type already defined in another module */
#ifdef SWIGRUNTIME_DEBUG
          printf("SWIG_InitializeModule: found cast %s\n", target_type->name);
#endif
          if (type == swig_module.type_initial[i]) {
#ifdef SWIGRUNTIME_DEBUG
            printf("SWIG_InitializeModule: skip old type %s\n", target_type->name);
#endif
            cast->type = target_type;
            target_type = 0;
          } else {
            /* Check if this cast is already in the list */
            swig_cast_info *ocast = SWIG_TypeCheck(target_type->name, type);
#ifdef SWIGRUNTIME_DEBUG
            if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", target_type->name);
#endif
            if (!ocast) target_type = 0;
          }
        }
      }
      
      if (!target_type) {
#ifdef SWIGRUNTIME_DEBUG
        printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
#endif
        /* Set inclusion mark for sorting */
        cast->next = cast;
        num_mapped++;
        
        if (type == cast->type) {
#ifdef SWIGRUNTIME_DEBUG
          printf("%s : self cast at pos [%li]\n", type->name, cast - first);
#endif
          if (cast - first) {
            /* Move cast to itself to the first entry in the array */
            
            swig_cast_info tmp = *cast;
            *cast = *first;
            *first = tmp;
          }
          first++;
          
        } else {
          cast->value = SWIG_Hash(cast->type->name, (unsigned int)strlen(cast->type->name));
        }
      }
      cast++;
    }
    
    if (num_mapped) {
      if (cast - first) {
        swig_cast_info *tmp;
        
        /* Sort casts by type address for binary search in SWIG_TypeCheckStruct */
        qsort(first, cast - first, sizeof(swig_cast_info), SWIG_CastCmpStruct);
        
        /* Remap back links for added entries */
        cast = swig_module.cast_initial[i] + num_mapped;
        for (tmp = first; tmp < cast; tmp++) {
          tmp->next = tmp;
        }
      }
      
      /* Set the value field of the first entry to the index of the last added entry */
      cast = swig_module.cast_initial[i];
      cast->value = num_mapped - 1;
      
      num_mapped -= (int)(first - cast);
      if (num_mapped > 1) {
        /* Sort <'next','value'> pairs by 'value' for binary search in SWIG_TypeCheck */
        
        SWIG_CastHashSort(first, num_mapped);
      }
      
      first = type->cast;
      if (first) {
        /* Link the current set into the list of cast arrays */
        cast->next = first->next;
        first->next = cast;
      } else {
        cast->next = 0;
        type->cast = cast;
      }
    }
    
    /* Set entry in modules->types array equal to the type */
    swig_module.types[i] = type;
  }
  swig_module.types[i] = 0;
  
#ifdef SWIGRUNTIME_DEBUG
  printf("**** SWIG_InitializeModule: Cast List ******\n");
  for (i = 0; i < swig_module.size; ++i) {
    int j = 0;
    swig_cast_info *cast = swig_module.cast_initial[i];
    printf("SWIG_InitializeModule: type %lu %s\n", (unsigned long)i, swig_module.type_initial[i]->name);
    while (cast->type) {
      printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
      cast++;
      ++j;
    }
    printf("---- Total casts: %d\n",j);
  }
  printf("**** SWIG_InitializeModule: Cast List ******\n");
#endif
}

/* This function will propagate the clientdata field of type to
* any new swig_type_info structures that have been added into the list
* of equivalent types.  It is like calling
* SWIG_TypeClientData(type, clientdata) a second time.
*/
SWIGRUNTIME void
SWIG_PropagateClientData(void) {
  size_t i;
  static int init_run = 0;
  
  if (init_run) return;
  init_run = 1;
  
  for (i = 0; i < swig_module.size; i++) {
    if (swig_module.types[i]->clientdata) {
      swig_cast_info *head, *cast;
      head = swig_module.types[i]->cast;
      while (head) {
        for (cast = head; (cast - head) <= head->value; cast++) {
          if (!cast->converter) {
            if (cast->type && !cast->type->clientdata)
            SWIG_TypeClientData(cast->type, swig_module.types[i]->clientdata);
          }
        }
        head = head->next;
      }
    }
  }
}

#ifdef __cplusplus
#if 0
{
  /* c-mode */
#endif
}
#endif



#ifdef __cplusplus
extern "C" {
#endif
  
  /* -----------------------------------------------------------------------------
   * constants/methods manipulation
   * ----------------------------------------------------------------------------- */
  
  /* Install Constants */
  SWIGINTERN void
  SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
    PyObject *obj = 0;
    size_t i;
    for (i = 0; constants[i].type; ++i) {
      switch(constants[i].type) {
      case SWIG_PY_POINTER:
        obj = SWIG_InternalNewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
        break;
      case SWIG_PY_BINARY:
        obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
        break;
      default:
        obj = 0;
        break;
      }
      if (obj) {
        PyDict_SetItemString(d, constants[i].name, obj);
        SWIG_Py_DECREF(obj);
      }
    }
  }
  
  /* -----------------------------------------------------------------------------
   * Patch %callback methods' docstrings to hold the callback ptrs
   * -----------------------------------------------------------------------------*/
  
  SWIGINTERN void
  SWIG_Python_FixMethods(PyMethodDef *methods, const swig_const_info *const_table, swig_type_info **types, swig_type_info **types_initial) {
    size_t i;
    for (i = 0; methods[i].ml_name; ++i) {
      const char *c = methods[i].ml_doc;
      if (!c) continue;
      c = strstr(c, "swig_ptr: ");
      if (c) {
        int j;
        const swig_const_info *ci = 0;
        const char *name = c + 10;
        for (j = 0; const_table[j].type; ++j) {
          if (strncmp(const_table[j].name, name, 
              strlen(const_table[j].name)) == 0) {
            ci = &(const_table[j]);
            break;
          }
        }
        if (ci) {
          void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
          if (ptr) {
            size_t shift = (ci->ptype) - types;
            swig_type_info *ty = types_initial[shift];
            size_t ldoc = (c - methods[i].ml_doc);
            size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
            char *ndoc = (char*)malloc(ldoc + lptr + 10);
            if (ndoc) {
              char *buff = ndoc;
              memcpy(buff, methods[i].ml_doc, ldoc);
              buff += ldoc;
              memcpy(buff, "swig_ptr: ", 10);
              buff += 10;
              SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
              methods[i].ml_doc = ndoc;
            }
          }
        }
      }
    }
  } 
  
#ifdef __cplusplus
}
#endif




/* -----------------------------------------------------------------------------*
 *  Partial Init method
 * -----------------------------------------------------------------------------*/

SWIGINTERN int SWIG_mod_exec(PyObject *module);

#ifdef __cplusplus
extern "C"
#endif

SWIGEXPORT 
#if PY_VERSION_HEX >= 0x03000000
PyObject*
#else
void
#endif
SWIG_init(void) {
#if PY_VERSION_HEX >= 0x03000000
  static PyModuleDef_Slot SwigSlots[] = {
    {
      Py_mod_exec, (void *)SWIG_mod_exec 
    },
#ifdef SWIGPYTHON_NOGIL
#ifdef Py_GIL_DISABLED
    {
      Py_mod_gil, Py_MOD_GIL_NOT_USED 
    },
#endif
#endif
    {
      0, NULL 
    }
  };
  
  static struct PyModuleDef SWIG_module = {
    PyModuleDef_HEAD_INIT,
    SWIG_name,
    NULL,
    0,
    SwigMethods,
    SwigSlots,
    NULL,
    NULL,
    NULL
  };
  
  return PyModuleDef_Init(&SWIG_module);
#else
  PyObject *m = Py_InitModule(SWIG_name, SwigMethods);
  if (m && SWIG_mod_exec(m) != 0) {
    Py_DECREF(m);
  }
#endif
}

SWIGINTERN int SWIG_mod_exec(PyObject *m) {
  PyObject *d, *md, *globals;
  
#if defined(SWIGPYTHON_BUILTIN)
  static SwigPyClientData SwigPyObject_clientdata = {
    0, 0, 0, 0, 0, 0, 0
  };
  static PyGetSetDef this_getset_def = {
    (char *)"this", &SwigPyBuiltin_ThisClosure, NULL, NULL, NULL
  };
  static SwigPyGetSet thisown_getset_closure = {
    SwigPyObject_own,
    SwigPyObject_own
  };
  static PyGetSetDef thisown_getset_def = {
    (char *)"thisown", SwigPyBuiltin_GetterClosure, SwigPyBuiltin_SetterClosure, NULL, &thisown_getset_closure
  };
  PyTypeObject *builtin_pytype;
  int builtin_base_count;
  swig_type_info *builtin_basetype;
  PyObject *tuple;
  PyGetSetDescrObject *static_getset;
  PyTypeObject *metatype;
  PyTypeObject *swigpyobject;
  SwigPyClientData *cd;
  PyObject *public_interface, *public_symbol;
  PyObject *this_descr;
  PyObject *thisown_descr;
  PyObject *self = 0;
  int i;
  
  (void)builtin_pytype;
  (void)builtin_base_count;
  (void)builtin_basetype;
  (void)tuple;
  (void)static_getset;
  (void)self;
  
  /* Metaclass is used to implement static member variables */
  metatype = SwigPyObjectType_Type();
  assert(metatype);
  
  SwigPyStaticVar_Type();
#endif
  
  (void)globals;
  
  /* Create singletons now to avoid potential deadlocks with multi-threaded usage after module initialization */
  SWIG_runtime_data_module();
  SWIG_This();
  SWIG_Python_TypeCache();
  SwigPyPacked_Type();
  SwigVarLink_Type();
#ifndef SWIGPYTHON_BUILTIN
  SwigPyObject_Type();
#endif
  
  /* Fix SwigMethods to carry the callback ptrs when needed */
  SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
  
#ifdef SWIGPYTHON_NOGIL
#ifdef Py_GIL_DISABLED
  PyUnstable_Module_SetGIL(m, Py_MOD_GIL_NOT_USED);
#endif
#endif
  
  md = d = PyModule_GetDict(m);
  (void)md;
  
  SWIG_InitializeModule(0);
  
#ifdef SWIGPYTHON_BUILTIN
  swigpyobject = SwigPyObject_TypeOnce();
  
  SwigPyObject_stype = SWIG_MangledTypeQuery("_p_SwigPyObject");
  assert(SwigPyObject_stype);
  cd = (SwigPyClientData*) SwigPyObject_stype->clientdata;
  if (!cd) {
    SwigPyObject_stype->clientdata = &SwigPyObject_clientdata;
    SwigPyObject_clientdata.pytype = swigpyobject;
  } else if (swigpyobject->tp_basicsize != cd->pytype->tp_basicsize) {
    PyErr_SetString(PyExc_RuntimeError, "Import error: attempted to load two incompatible swig-generated modules.");
    return -1;
  }
  
  /* All objects have a 'this' attribute */
  this_descr = PyDescr_NewGetSet(SwigPyObject_Type(), &this_getset_def);
  (void)this_descr;
  
  /* All objects have a 'thisown' attribute */
  thisown_descr = PyDescr_NewGetSet(SwigPyObject_Type(), &thisown_getset_def);
  (void)thisown_descr;
  
  public_interface = PyList_New(0);
  public_symbol = 0;
  (void)public_symbol;
  
  PyDict_SetItemString(md, "__all__", public_interface);
  SWIG_Py_DECREF(public_interface);
  for (i = 0; SwigMethods[i].ml_name != NULL; ++i)
  SwigPyBuiltin_AddPublicSymbol(public_interface, SwigMethods[i].ml_name);
  for (i = 0; swig_const_table[i].name != 0; ++i)
  SwigPyBuiltin_AddPublicSymbol(public_interface, swig_const_table[i].name);
#endif
  
  SWIG_InstallConstants(d,swig_const_table);
  
  SWIG_Python_SetConstant(d, "JUNKBUFSIZE",SWIG_From_int(static_cast< int >(65534)));
  globals = SWIG_globals();
  if (!globals) {
    PyErr_SetString(PyExc_TypeError, "Failure to create SWIG globals.");
    return -1;
  }
  PyDict_SetItemString(md, "cvar", globals);
  
  // thread safe initialization
  swig::container_owner_attribute();
  
  SWIG_Python_SetConstant(d, "SWORD_VERSION_NUM",SWIG_From_int(static_cast< int >(1009000000)));
  SWIG_Python_SetConstant(d, "SWORD_VERSION_STR",SWIG_FromCharPtr("1.9.0"));
  SWIG_Python_SetConstant(d, "SWORD_VERSION_MAJOR",SWIG_From_int(static_cast< int >(1)));
  SWIG_Python_SetConstant(d, "SWORD_VERSION_MINOR",SWIG_From_int(static_cast< int >(9)));
  SWIG_Python_SetConstant(d, "SWORD_VERSION_MICRO",SWIG_From_int(static_cast< int >(0)));
  SWIG_Python_SetConstant(d, "SWORD_VERSION_NANO",SWIG_From_int(static_cast< int >(0)));
  SWIG_Python_SetConstant(d, "VERSEBLOCKS",SWIG_From_int(static_cast< int >(2)));
  SWIG_Python_SetConstant(d, "CHAPTERBLOCKS",SWIG_From_int(static_cast< int >(3)));
  SWIG_Python_SetConstant(d, "BOOKBLOCKS",SWIG_From_int(static_cast< int >(4)));
  SWIG_Python_SetConstant(d, "KEYERR_OUTOFBOUNDS",SWIG_From_int(static_cast< int >(1)));
  SWIG_Python_SetConstant(d, "DIRECTION_LTR",SWIG_From_int(static_cast< int >(sword::DIRECTION_LTR)));
  SWIG_Python_SetConstant(d, "DIRECTION_RTL",SWIG_From_int(static_cast< int >(sword::DIRECTION_RTL)));
  SWIG_Python_SetConstant(d, "DIRECTION_BIDI",SWIG_From_int(static_cast< int >(sword::DIRECTION_BIDI)));
  SWIG_Python_SetConstant(d, "FMT_UNKNOWN",SWIG_From_int(static_cast< int >(sword::FMT_UNKNOWN)));
  SWIG_Python_SetConstant(d, "FMT_PLAIN",SWIG_From_int(static_cast< int >(sword::FMT_PLAIN)));
  SWIG_Python_SetConstant(d, "FMT_THML",SWIG_From_int(static_cast< int >(sword::FMT_THML)));
  SWIG_Python_SetConstant(d, "FMT_GBF",SWIG_From_int(static_cast< int >(sword::FMT_GBF)));
  SWIG_Python_SetConstant(d, "FMT_HTML",SWIG_From_int(static_cast< int >(sword::FMT_HTML)));
  SWIG_Python_SetConstant(d, "FMT_HTMLHREF",SWIG_From_int(static_cast< int >(sword::FMT_HTMLHREF)));
  SWIG_Python_SetConstant(d, "FMT_RTF",SWIG_From_int(static_cast< int >(sword::FMT_RTF)));
  SWIG_Python_SetConstant(d, "FMT_OSIS",SWIG_From_int(static_cast< int >(sword::FMT_OSIS)));
  SWIG_Python_SetConstant(d, "FMT_WEBIF",SWIG_From_int(static_cast< int >(sword::FMT_WEBIF)));
  SWIG_Python_SetConstant(d, "FMT_TEI",SWIG_From_int(static_cast< int >(sword::FMT_TEI)));
  SWIG_Python_SetConstant(d, "FMT_XHTML",SWIG_From_int(static_cast< int >(sword::FMT_XHTML)));
  SWIG_Python_SetConstant(d, "FMT_LATEX",SWIG_From_int(static_cast< int >(sword::FMT_LATEX)));
  SWIG_Python_SetConstant(d, "ENC_UNKNOWN",SWIG_From_int(static_cast< int >(sword::ENC_UNKNOWN)));
  SWIG_Python_SetConstant(d, "ENC_LATIN1",SWIG_From_int(static_cast< int >(sword::ENC_LATIN1)));
  SWIG_Python_SetConstant(d, "ENC_UTF8",SWIG_From_int(static_cast< int >(sword::ENC_UTF8)));
  SWIG_Python_SetConstant(d, "ENC_SCSU",SWIG_From_int(static_cast< int >(sword::ENC_SCSU)));
  SWIG_Python_SetConstant(d, "ENC_UTF16",SWIG_From_int(static_cast< int >(sword::ENC_UTF16)));
  SWIG_Python_SetConstant(d, "ENC_RTF",SWIG_From_int(static_cast< int >(sword::ENC_RTF)));
  SWIG_Python_SetConstant(d, "ENC_HTML",SWIG_From_int(static_cast< int >(sword::ENC_HTML)));
  SWIG_Python_SetConstant(d, "BIB_BIBTEX",SWIG_From_int(static_cast< int >(sword::BIB_BIBTEX)));
  SWIG_Python_SetConstant(d, "SEARCHFLAG_MATCHWHOLEENTRY",SWIG_From_int(static_cast< int >(4096)));
  SWIG_Python_SetConstant(d, "SEARCHFLAG_STRICTBOUNDARIES",SWIG_From_int(static_cast< int >(8192)));
  SWIG_Python_SetConstant(d, "FAILED",SWIG_From_int(static_cast< int >(0)));
  SWIG_Python_SetConstant(d, "SUCCEEDED",SWIG_From_int(static_cast< int >(1)));
  SWIG_Python_SetConstant(d, "INHERITED",SWIG_From_int(static_cast< int >(2)));
  SWIG_addvarlink(globals, "SWBuf_nullStr", Swig_var_SWBuf_nullStr_get, Swig_var_SWBuf_nullStr_set);
  SWIG_addvarlink(globals, "SWVersion_currentVersion", Swig_var_SWVersion_currentVersion_get, Swig_var_SWVersion_currentVersion_set);
  SWIG_addvarlink(globals, "RawVerse_nl", Swig_var_RawVerse_nl_get, Swig_var_RawVerse_nl_set);
  SWIG_addvarlink(globals, "zVerse_uniqueIndexID", Swig_var_zVerse_uniqueIndexID_get, Swig_var_zVerse_uniqueIndexID_set);
  SWIG_addvarlink(globals, "RawStr_nl", Swig_var_RawStr_nl_get, Swig_var_RawStr_nl_set);
  SWIG_addvarlink(globals, "RawStr4_nl", Swig_var_RawStr4_nl_get, Swig_var_RawStr4_nl_set);
  SWIG_addvarlink(globals, "builtin_abbrevs", Swig_var_builtin_abbrevs_get, Swig_var_builtin_abbrevs_set);
  SWIG_addvarlink(globals, "SWMgr_MODTYPE_BIBLES", Swig_var_SWMgr_MODTYPE_BIBLES_get, Swig_var_SWMgr_MODTYPE_BIBLES_set);
  SWIG_addvarlink(globals, "SWMgr_MODTYPE_COMMENTARIES", Swig_var_SWMgr_MODTYPE_COMMENTARIES_get, Swig_var_SWMgr_MODTYPE_COMMENTARIES_set);
  SWIG_addvarlink(globals, "SWMgr_MODTYPE_LEXDICTS", Swig_var_SWMgr_MODTYPE_LEXDICTS_get, Swig_var_SWMgr_MODTYPE_LEXDICTS_set);
  SWIG_addvarlink(globals, "SWMgr_MODTYPE_GENBOOKS", Swig_var_SWMgr_MODTYPE_GENBOOKS_get, Swig_var_SWMgr_MODTYPE_GENBOOKS_set);
  SWIG_addvarlink(globals, "SWMgr_MODTYPE_DAILYDEVOS", Swig_var_SWMgr_MODTYPE_DAILYDEVOS_get, Swig_var_SWMgr_MODTYPE_DAILYDEVOS_set);
  SWIG_addvarlink(globals, "SWMgr_isICU", Swig_var_SWMgr_isICU_get, Swig_var_SWMgr_isICU_set);
  SWIG_addvarlink(globals, "SWMgr_globalConfPath", Swig_var_SWMgr_globalConfPath_get, Swig_var_SWMgr_globalConfPath_set);
  SWIG_addvarlink(globals, "FileMgr_CREAT", Swig_var_FileMgr_CREAT_get, Swig_var_FileMgr_CREAT_set);
  SWIG_addvarlink(globals, "FileMgr_APPEND", Swig_var_FileMgr_APPEND_get, Swig_var_FileMgr_APPEND_set);
  SWIG_addvarlink(globals, "FileMgr_TRUNC", Swig_var_FileMgr_TRUNC_get, Swig_var_FileMgr_TRUNC_set);
  SWIG_addvarlink(globals, "FileMgr_RDONLY", Swig_var_FileMgr_RDONLY_get, Swig_var_FileMgr_RDONLY_set);
  SWIG_addvarlink(globals, "FileMgr_RDWR", Swig_var_FileMgr_RDWR_get, Swig_var_FileMgr_RDWR_set);
  SWIG_addvarlink(globals, "FileMgr_WRONLY", Swig_var_FileMgr_WRONLY_get, Swig_var_FileMgr_WRONLY_set);
  SWIG_addvarlink(globals, "FileMgr_IREAD", Swig_var_FileMgr_IREAD_get, Swig_var_FileMgr_IREAD_set);
  SWIG_addvarlink(globals, "FileMgr_IWRITE", Swig_var_FileMgr_IWRITE_get, Swig_var_FileMgr_IWRITE_set);
  SWIG_addvarlink(globals, "ENDOFABBREVS", Swig_var_ENDOFABBREVS_get, Swig_var_ENDOFABBREVS_set);
  SWIG_addvarlink(globals, "SWLocale_DEFAULT_LOCALE_NAME", Swig_var_SWLocale_DEFAULT_LOCALE_NAME_get, Swig_var_SWLocale_DEFAULT_LOCALE_NAME_set);
  SWIG_addvarlink(globals, "SWLog_LOG_ERROR", Swig_var_SWLog_LOG_ERROR_get, Swig_var_SWLog_LOG_ERROR_set);
  SWIG_addvarlink(globals, "SWLog_LOG_WARN", Swig_var_SWLog_LOG_WARN_get, Swig_var_SWLog_LOG_WARN_set);
  SWIG_addvarlink(globals, "SWLog_LOG_INFO", Swig_var_SWLog_LOG_INFO_get, Swig_var_SWLog_LOG_INFO_set);
  SWIG_addvarlink(globals, "SWLog_LOG_TIMEDINFO", Swig_var_SWLog_LOG_TIMEDINFO_get, Swig_var_SWLog_LOG_TIMEDINFO_set);
  SWIG_addvarlink(globals, "SWLog_LOG_DEBUG", Swig_var_SWLog_LOG_DEBUG_get, Swig_var_SWLog_LOG_DEBUG_set);
  SWIG_addvarlink(globals, "InstallMgr_userDisclaimerConfirmed", Swig_var_InstallMgr_userDisclaimerConfirmed_get, Swig_var_InstallMgr_userDisclaimerConfirmed_set);
  SWIG_addvarlink(globals, "InstallMgr_MODSTAT_OLDER", Swig_var_InstallMgr_MODSTAT_OLDER_get, Swig_var_InstallMgr_MODSTAT_OLDER_set);
  SWIG_addvarlink(globals, "InstallMgr_MODSTAT_SAMEVERSION", Swig_var_InstallMgr_MODSTAT_SAMEVERSION_get, Swig_var_InstallMgr_MODSTAT_SAMEVERSION_set);
  SWIG_addvarlink(globals, "InstallMgr_MODSTAT_UPDATED", Swig_var_InstallMgr_MODSTAT_UPDATED_get, Swig_var_InstallMgr_MODSTAT_UPDATED_set);
  SWIG_addvarlink(globals, "InstallMgr_MODSTAT_NEW", Swig_var_InstallMgr_MODSTAT_NEW_get, Swig_var_InstallMgr_MODSTAT_NEW_set);
  SWIG_addvarlink(globals, "InstallMgr_MODSTAT_CIPHERED", Swig_var_InstallMgr_MODSTAT_CIPHERED_get, Swig_var_InstallMgr_MODSTAT_CIPHERED_set);
  SWIG_addvarlink(globals, "InstallMgr_MODSTAT_CIPHERKEYPRESENT", Swig_var_InstallMgr_MODSTAT_CIPHERKEYPRESENT_get, Swig_var_InstallMgr_MODSTAT_CIPHERKEYPRESENT_set);
  return 0;
}

