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


#ifdef __cplusplus
template<class T> class SwigValueWrapper {
    T *tt;
public:
    inline SwigValueWrapper() : tt(0) { }
    inline ~SwigValueWrapper() { if (tt) delete tt; } 
    inline SwigValueWrapper& operator=(const T& t) { tt = new T(t); return *this; }
    inline operator T&() const { return *tt; }
    inline T *operator&() { return tt; }
};                                                    
#endif

/***********************************************************************
 * common.swg
 *
 *     This file contains generic SWIG runtime support for pointer
 *     type checking as well as a few commonly used macros to control
 *     external linkage.
 *
 * Author : David Beazley (beazley@cs.uchicago.edu)
 *
 * Copyright (c) 1999-2000, The University of Chicago
 * 
 * This file may be freely redistributed without license or fee provided
 * this copyright message remains intact.
 ************************************************************************/

#include <string.h>

#if defined(_WIN32) || defined(__WIN32__)
#       if defined(_MSC_VER)
#               if defined(STATIC_LINKED)
#                       define SWIGEXPORT(a) a
#                       define SWIGIMPORT(a) extern a
#               else
#                       define SWIGEXPORT(a) __declspec(dllexport) a
#                       define SWIGIMPORT(a) extern a
#               endif
#       else
#               if defined(__BORLANDC__)
#                       define SWIGEXPORT(a) a _export
#                       define SWIGIMPORT(a) a _export
#               else
#                       define SWIGEXPORT(a) a
#                       define SWIGIMPORT(a) a
#               endif
#       endif
#else
#       define SWIGEXPORT(a) a
#       define SWIGIMPORT(a) a
#endif

#ifdef SWIG_GLOBAL
#define SWIGRUNTIME(a) SWIGEXPORT(a)
#else
#define SWIGRUNTIME(a) static a
#endif

#ifdef __cplusplus
extern "C" {
#endif

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

typedef struct swig_type_info {
  const char             *name;                 
  swig_converter_func     converter;
  const char             *str;
  void                   *clientdata;	
  swig_dycast_func        dcast;
  struct swig_type_info  *next;
  struct swig_type_info  *prev;
} swig_type_info;

#ifdef SWIG_NOINCLUDE

SWIGIMPORT(swig_type_info *) SWIG_TypeRegister(swig_type_info *);
SWIGIMPORT(swig_type_info *) SWIG_TypeCheck(char *c, swig_type_info *);
SWIGIMPORT(void *)           SWIG_TypeCast(swig_type_info *, void *);
SWIGIMPORT(swig_type_info *) SWIG_TypeDynamicCast(swig_type_info *, void **);
SWIGIMPORT(const char *)     SWIG_TypeName(const swig_type_info *);
SWIGIMPORT(swig_type_info *) SWIG_TypeQuery(const char *);
SWIGIMPORT(void)             SWIG_TypeClientData(swig_type_info *, void *);

#else

static swig_type_info *swig_type_list = 0;

/* Register a type mapping with the type-checking */
SWIGRUNTIME(swig_type_info *)
SWIG_TypeRegister(swig_type_info *ti)
{
  swig_type_info *tc, *head, *ret, *next;
  /* Check to see if this type has already been registered */
  tc = swig_type_list;
  while (tc) {
    if (strcmp(tc->name, ti->name) == 0) {
      /* Already exists in the table.  Just add additional types to the list */
      if (tc->clientdata) ti->clientdata = tc->clientdata;	
      head = tc;
      next = tc->next;
      goto l1;
    }
    tc = tc->prev;
  }
  head = ti;
  next = 0;

  /* Place in list */
  ti->prev = swig_type_list;
  swig_type_list = ti;

  /* Build linked lists */
 l1:
  ret = head;
  tc = ti + 1;
  /* Patch up the rest of the links */
  while (tc->name) {
    head->next = tc;
    tc->prev = head;
    head = tc;
    tc++;
  }
  if (next) next->prev = head;  /**/
  head->next = next;
  return ret;
}

/* Check the typename */
SWIGRUNTIME(swig_type_info *) 
SWIG_TypeCheck(char *c, swig_type_info *ty)
{
  swig_type_info *s;
  if (!ty) return 0;        /* Void pointer */
  s = ty->next;             /* First element always just a name */
  do {
    if (strcmp(s->name,c) == 0) {
      if (s == ty->next) return s;
      /* Move s to the top of the linked list */
      s->prev->next = s->next;
      if (s->next) {
	s->next->prev = s->prev;
      }
      /* Insert s as second element in the list */
      s->next = ty->next;
      if (ty->next) ty->next->prev = s;
      ty->next = s;
      s->prev = ty;  /**/
      return s;
    }
    s = s->next;
  } while (s && (s != ty->next));
  return 0;
}

/* Cast a pointer up an inheritance hierarchy */
SWIGRUNTIME(void *) 
SWIG_TypeCast(swig_type_info *ty, void *ptr) 
{
  if ((!ty) || (!ty->converter)) return ptr;
  return (*ty->converter)(ptr);
}

/* 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 */
SWIGRUNTIME(const char *)
SWIG_TypeName(const swig_type_info *ty) {
  return ty->name;
}

/* Search for a swig_type_info structure */
SWIGRUNTIME(swig_type_info *)
SWIG_TypeQuery(const char *name) {
  swig_type_info *ty = swig_type_list;
  while (ty) {
    if (ty->str && (strcmp(name,ty->str) == 0)) return ty;
    if (ty->name && (strcmp(name,ty->name) == 0)) return ty;
    ty = ty->prev;
  }
  return 0;
}

/* Set the clientdata field for a type */
SWIGRUNTIME(void)
SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
  swig_type_info *tc, *equiv;
  if (ti->clientdata == clientdata) return;
  ti->clientdata = clientdata;
  equiv = ti->next;
  while (equiv) {
    if (!equiv->converter) {
      tc = swig_type_list;
      while (tc) {
	if ((strcmp(tc->name, equiv->name) == 0))
	  SWIG_TypeClientData(tc,clientdata);
	tc = tc->prev;
      }
    }
    equiv = equiv->next;
  }
}
#endif

#ifdef __cplusplus
}

#endif

/* -----------------------------------------------------------------------------
 * perl5.swg
 *
 * Perl5 runtime library
 * $Header: /cvs/core/sword/bindings/swig/perl/Sword.cxx,v 1.14 2003/07/17 21:38:30 dglassey Exp $
 * ----------------------------------------------------------------------------- */

#define SWIGPERL
#define SWIGPERL5
#ifdef __cplusplus
/* Needed on some windows machines---since MS plays funny
   games with the header files under C++ */
#include <math.h>
#include <stdlib.h>
extern "C" {
#endif
#include "EXTERN.h"
#include "perl.h"
#include "XSUB.h"

/* Get rid of free and malloc defined by perl */
#undef free
#undef malloc

#ifndef pTHX_
#define pTHX_
#endif

#include <string.h>
#ifdef __cplusplus
}
#endif

/* Macro to call an XS function */

#ifdef PERL_OBJECT 
#define SWIG_CALLXS(_name) _name(cv,pPerl) 
#else 
#ifndef MULTIPLICITY 
#define SWIG_CALLXS(_name) _name(cv) 
#else 
#define SWIG_CALLXS(_name) _name(PERL_GET_THX, cv) 
#endif 
#endif 

/* Macros for low-level exception handling */
#define SWIG_fail      goto fail
#define SWIG_croak(x)  { if ((_swigerr = (const char *) x)) goto fail; }
#define SWIG_MAX_ERRMSG 256

/* Note: SwigMagicFuncHack is a typedef used to get the C++
   compiler to just shut up already */

#ifdef PERL_OBJECT
#define MAGIC_PPERL  CPerlObj *pPerl = (CPerlObj *) this;
typedef int (CPerlObj::*SwigMagicFunc)(SV *, MAGIC *);

#ifdef __cplusplus
extern "C" {
#endif
typedef int (CPerlObj::*SwigMagicFuncHack)(SV *, MAGIC *);
#ifdef __cplusplus
}
#endif

#define SWIG_MAGIC(a,b) (SV *a, MAGIC *b)
#define SWIGCLASS_STATIC
#else
#define MAGIC_PPERL
#define SWIGCLASS_STATIC static
#ifndef MULTIPLICITY
#define SWIG_MAGIC(a,b) (SV *a, MAGIC *b)
typedef int (*SwigMagicFunc)(SV *, MAGIC *);

#ifdef __cplusplus
extern "C" {
#endif
typedef int (*SwigMagicFuncHack)(SV *, MAGIC *);
#ifdef __cplusplus
}
#endif


#else
#define SWIG_MAGIC(a,b) (struct interpreter *interp, SV *a, MAGIC *b)
typedef int (*SwigMagicFunc)(struct interpreter *, SV *, MAGIC *);
#ifdef __cplusplus
extern "C" {
#endif
typedef int (*SwigMagicFuncHack)(struct interpreter *, SV *, MAGIC *);
#ifdef __cplusplus
}
#endif

#endif
#endif

#if defined(WIN32) && defined(PERL_OBJECT) && !defined(PerlIO_exportFILE)
#define PerlIO_exportFILE(fh,fl) (FILE*)(fh)
#endif

/* Modifications for newer Perl 5.005 releases */

#if !defined(PERL_REVISION) || ((PERL_REVISION >= 5) && ((PERL_VERSION < 5) || ((PERL_VERSION == 5) && (PERL_SUBVERSION < 50))))
#ifndef PL_sv_yes
#define PL_sv_yes sv_yes
#endif
#ifndef PL_sv_undef
#define PL_sv_undef sv_undef
#endif
#ifndef PL_na
#define PL_na na
#endif
#endif

#include <stdlib.h>

#ifdef __cplusplus
extern "C" {
#endif

#ifdef SWIG_NOINCLUDE

#ifndef PERL_OBJECT
extern int SWIG_ConvertPtr(SV *, void **, swig_type_info *, int flags);
extern void SWIG_MakePtr(SV *, void *, swig_type_info *, int flags);
#else
extern int _SWIG_ConvertPtr(CPerlObj *, SV *, void **, swig_type_info *,int flags);
extern void _SWIG_MakePtr(CPerlObj *, SV *, void *, swig_type_info *, int flags);
#define SWIG_ConvertPtr(a,b,c,d) _SWIG_ConvertPtr(pPerl,a,b,c,d)
#define SWIG_MakePtr(a,b,c,d) _SWIG_MakePtr(pPerl,a,b,c,d)
#endif

#else

/* Function for getting a pointer value */

#ifndef PERL_OBJECT
SWIGRUNTIME(int) 
SWIG_ConvertPtr(SV *sv, void **ptr, swig_type_info *_t, int flags)
#else
#define SWIG_ConvertPtr(a,b,c,d) _SWIG_ConvertPtr(pPerl,a,b,c,d)
SWIGRUNTIME(int)
_SWIG_ConvertPtr(CPerlObj *pPerl, SV *sv, void **ptr, swig_type_info *_t, int flags)
#endif
{
  char *_c;
  swig_type_info *tc;
  IV   tmp;

  /* If magical, apply more magic */
  if (SvGMAGICAL(sv))
    mg_get(sv);

  /* Check to see if this is an object */
  if (sv_isobject(sv)) {
    SV *tsv = (SV*) SvRV(sv);
    if ((SvTYPE(tsv) == SVt_PVHV)) {
      MAGIC *mg;
      if (SvMAGICAL(tsv)) {
	mg = mg_find(tsv,'P');
	if (mg) {
	  SV *rsv = mg->mg_obj;
	  if (sv_isobject(rsv)) {
	    tmp = SvIV((SV*)SvRV(rsv));
	  }
	}
      } else {
	return -1;
      }
    } else {
      tmp = SvIV((SV*)SvRV(sv));
    }
    if (!_t) {
      *(ptr) = (void *) tmp;
      return 0;
    }
  } else if (! SvOK(sv)) {            /* Check for undef */
    *(ptr) = (void *) 0;
    return 0;
  } else if (SvTYPE(sv) == SVt_RV) {  /* Check for NULL pointer */
    *(ptr) = (void *) 0;
    if (!SvROK(sv)) 
      return 0;
    else
      return -1;
  } else {                            /* Don't know what it is */
      *(ptr) = (void *) 0;
      return -1;
  }
  if (_t) {
    /* Now see if the types match */      
    _c = HvNAME(SvSTASH(SvRV(sv)));
    tc = SWIG_TypeCheck(_c,_t);
    if (!tc) {
      *ptr = (void *) tmp;
      return -1;
    }
    *ptr = SWIG_TypeCast(tc,(void *)tmp);
    return 0;
  }
  *ptr = (void *) tmp;
  return 0;
}
#ifndef PERL_OBJECT
SWIGRUNTIME(void) 
SWIG_MakePtr(SV *sv, void *ptr, swig_type_info *t,int flags)
#else
#define SWIG_MakePtr(a,b,c,d) _SWIG_MakePtr(pPerl,a,b,c,d)
SWIGRUNTIME(void)
_SWIG_MakePtr(CPerlObj *pPerl, SV *sv, void *ptr, swig_type_info *t, int flags)
#endif
{
  sv_setref_pv(sv, (char *) t->name, ptr);
}

#endif

typedef XS(SwigPerlWrapper);
typedef SwigPerlWrapper *SwigPerlWrapperPtr;

/* Structure for command table */
typedef struct {
  const char         *name;
  SwigPerlWrapperPtr  wrapper;
} swig_command_info;

/* Information for constant table */

#define SWIG_INT     1
#define SWIG_FLOAT   2
#define SWIG_STRING  3
#define SWIG_POINTER 4
#define SWIG_BINARY  5

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

#ifdef __cplusplus
}
#endif

/* Structure for variable table */
typedef struct {
  const char   *name;
  SwigMagicFunc   set;
  SwigMagicFunc   get;
  swig_type_info  **type;
} swig_variable_info;

/* Magic variable code */
#ifndef PERL_OBJECT
#define swig_create_magic(s,a,b,c) _swig_create_magic(s,a,b,c)
  #ifndef MULTIPLICITY 
       static void _swig_create_magic(SV *sv, char *name, int (*set)(SV *, MAGIC *), int \
(*get)(SV *,MAGIC *)) { 
  #else 
       static void _swig_create_magic(SV *sv, char *name, int (*set)(struct interpreter*,\
 SV *, MAGIC *), int (*get)(struct interpreter*, SV *,MAGIC *)) { 
  #endif 
#else
#define swig_create_magic(s,a,b,c) _swig_create_magic(pPerl,s,a,b,c)
static void _swig_create_magic(CPerlObj *pPerl, SV *sv, const char *name, int (CPerlObj::*set)(SV *, MAGIC *), int (CPerlObj::*get)(SV *, MAGIC *)) {
#endif
  MAGIC *mg;
  sv_magic(sv,sv,'U',(char *) name,strlen(name));
  mg = mg_find(sv,'U');
  mg->mg_virtual = (MGVTBL *) malloc(sizeof(MGVTBL));
  mg->mg_virtual->svt_get = (SwigMagicFuncHack) get;
  mg->mg_virtual->svt_set = (SwigMagicFuncHack) set;
  mg->mg_virtual->svt_len = 0;
  mg->mg_virtual->svt_clear = 0;
  mg->mg_virtual->svt_free = 0;
}






#ifdef do_open
  #undef do_open
#endif
#ifdef do_close
  #undef do_close
#endif
#ifdef scalar
  #undef scalar
#endif
#ifdef list
  #undef list
#endif
#ifdef apply
  #undef apply
#endif
#ifdef convert
  #undef convert
#endif
#ifdef Error
  #undef Error
#endif
#ifdef form
  #undef form
#endif
#ifdef vform
  #undef vform
#endif
#ifdef LABEL
  #undef LABEL
#endif
#ifdef METHOD
  #undef METHOD
#endif
#ifdef Move
  #undef Move
#endif
#ifdef yylex
  #undef yylex
#endif
#ifdef yyparse
  #undef yyparse
#endif
#ifdef yyerror
  #undef yyerror
#endif
#ifdef invert
  #undef invert
#endif
#ifdef ref
  #undef ref
#endif


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

#define  SWIGTYPE_p_SWLocale swig_types[0] 
#define  SWIGTYPE_p_SWMgr swig_types[1] 
#define  SWIGTYPE_p_SWCom swig_types[2] 
#define  SWIGTYPE_p_RawLD4 swig_types[3] 
#define  SWIGTYPE_p_ListKey swig_types[4] 
#define  SWIGTYPE_p_SWKey swig_types[5] 
#define  SWIGTYPE_p_ConfigEntMap swig_types[6] 
#define  SWIGTYPE_p_p_char swig_types[7] 
#define  SWIGTYPE_p_RawLD swig_types[8] 
#define  SWIGTYPE_p_char swig_types[9] 
#define  SWIGTYPE_p_TreeKey swig_types[10] 
#define  SWIGTYPE_p_StringList swig_types[11] 
#define  SWIGTYPE_p_bool swig_types[12] 
#define  SWIGTYPE_p_SWFilterMgr swig_types[13] 
#define  SWIGTYPE_p_SWLD swig_types[14] 
#define  SWIGTYPE_p_SWTextDirection swig_types[15] 
#define  SWIGTYPE_p_RawText swig_types[16] 
#define  SWIGTYPE_p_f_char_p_void__void swig_types[17] 
#define  SWIGTYPE_p_VerseKey swig_types[18] 
#define  SWIGTYPE_p_SWBuf swig_types[19] 
#define  SWIGTYPE_p_ModMap swig_types[20] 
#define  SWIGTYPE_p_zCom swig_types[21] 
#define  SWIGTYPE_p_SectionMap swig_types[22] 
#define  SWIGTYPE_p_SWDisplay swig_types[23] 
#define  SWIGTYPE_p_AttributeTypeList swig_types[24] 
#define  SWIGTYPE_p_SWText swig_types[25] 
#define  SWIGTYPE_p_std__listTSWBuf_t swig_types[26] 
#define  SWIGTYPE_p_TreeKeyIdx swig_types[27] 
#define  SWIGTYPE_p_SWCompress swig_types[28] 
#define  SWIGTYPE_p_LZSSCompress swig_types[29] 
#define  SWIGTYPE_p_ZipCompress swig_types[30] 
#define  SWIGTYPE_p_SW_POSITION swig_types[31] 
#define  SWIGTYPE_p_SWModule swig_types[32] 
#define  SWIGTYPE_p_zLD swig_types[33] 
#define  SWIGTYPE_p_SWGenBook swig_types[34] 
#define  SWIGTYPE_p_RawCom swig_types[35] 
#define  SWIGTYPE_p_RawGenBook swig_types[36] 
#define  SWIGTYPE_p_SWConfig swig_types[37] 
#define  SWIGTYPE_p_LocaleMgr swig_types[38] 
#define  SWIGTYPE_p_int swig_types[39] 
#define  SWIGTYPE_p_SWTextMarkup swig_types[40] 
#define  SWIGTYPE_p_zText swig_types[41] 
#define  SWIGTYPE_p_SWTextEncoding swig_types[42] 
#define  SWIGTYPE_p_unsigned_long swig_types[43] 
static swig_type_info *swig_types[45];

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

#define SWIG_init    boot_Sword

#define SWIG_name   "Swordc::boot_Sword"
#define SWIG_prefix "Swordc::"

#ifdef __cplusplus
extern "C"
#endif
#ifndef PERL_OBJECT
#ifndef MULTIPLICITY
SWIGEXPORT(void) SWIG_init (CV* cv);
#else
SWIGEXPORT(void) SWIG_init (pTHXo_ CV* cv);
#endif
#else
SWIGEXPORT(void) SWIG_init (CV *cv, CPerlObj *);
#endif


#undef bool
#undef assert
#undef LOCAL
#undef list


#include <stdio.h>
#include <string>
//#include <map>
#include <defs.h>
//#include <multimapwdef.h>
#include "swconfig.h"

using namespace sword;
using namespace std;


#define  SWIG_MemoryError    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_UnknownError  99


#define SWIG_exception(a,b)   SWIG_croak(b)


#include <vector>
#include <algorithm>
#include <stdexcept>


#include <string>

void SWConfig_set(SWConfig *self,char const *group,char const *entry,char const *value){
	self->Sections[group][entry] = value;
  }
char const *SWConfig_get(SWConfig *self,char const *group,char const *entry){
	return self->Sections[group][entry].c_str();
  }

#include <swmgr.h>
using namespace sword;

int const SWMgr_moduleCount(SWMgr *self){
		return self->Modules.size();
	}
SWModule *SWMgr_getModuleAt(SWMgr *self,int const pos){
		if (pos < 0 || pos > self->Modules.size() )
			return 0;
	
		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 "swmodule.h"
using namespace sword;

bool const SWModule_next(SWModule *self){
	(*self)++;
	return !self->Error();
  }
bool const SWModule_prev(SWModule *self){
	(*self)--;
	return !self->Error();
  }
bool const SWModule_inc(SWModule *self,int const howFar){
  	(*self)+=howFar;
	return !self->Error();
  }
bool const SWModule_dec(SWModule *self,int const howFar){
  	(*self)-=howFar;
	return !self->Error();
  }
void SWModule_setPosition(SWModule *self,SW_POSITION pos){
  	(*self) = pos;
  }
void SWModule_top(SWModule *self){
	(*self) = TOP;
  }
void SWModule_bottom(SWModule *self){
	(*self) = BOTTOM;
  }
char const *SWModule_text(SWModule *self){
  	return (const char*)*self;
  }
char const *SWModule_StripText(SWModule *self){
  	return self->StripText();
  }
void SWModule_write(SWModule *self,char const *text){
    (*self) << text;
  }
void SWModule_writeLink(SWModule *self,SWKey const *key){
    (*self) << key;
  }

#include "swkey.h"
#include "versekey.h"
using namespace sword;

void SWKey_setPersist(SWKey *self,signed char persists){
  	self->Persist(persists);
  }
void SWKey_next(SWKey *self){
  	(*self)++;
  }
void SWKey_prev(SWKey *self){
  	(*self)++;
  }
void SWKey_setKey(SWKey *self,SWKey const *key){
  	self->copyFrom(*key);
  }
VerseKey *SWKey_toVerseKey(SWKey *self){
	return dynamic_cast<VerseKey*>(self);
  }

#include "versekey.h"
#include "listkey.h"
using namespace sword;

int const VerseKey_bookCount(VerseKey *self,int const testament){
		if ( (testament < 1) || (testament > 2) ) {
			return 0;
		};
		return self->BMAX[testament-1];
	}
char const *VerseKey_bookName(VerseKey *self,int const testament,int const book){
		if ( (testament < 1) || (testament > 2) ) {
			return "";
		};
		if ( (book < 1) || (book > self->BMAX[testament-1]) ) {
			return "";
		}

		return self->books[testament-1][book-1].name;
	}
int const VerseKey_chapterCount(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;
		}

		return self->books[testament-1][book-1].chapmax;
	}
int const VerseKey_verseCount(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;
		}
		if ( (chapter < 1) || (chapter > self->books[testament-1][book-1].chapmax) ) {
			return 0;
		}

		return self->books[testament-1][book-1].versemax[chapter-1];

	}

#include "listkey.h"
using namespace sword;

char ListKey_SetToElement(ListKey *self,int element){
		return self->SetToElement(element, SW_POSITION(((char)1)));
	}

#include "treekey.h"
using namespace sword;


#include "treekeyidx.h"
using namespace sword;


#include <localemgr.h>

using namespace std;
using namespace sword;

LocaleMgr *const LocaleMgr_getSystemLocaleMgr(){
  	return &(LocaleMgr::systemLocaleMgr);
  }

#include <swfiltermgr.h>
using namespace sword;


#include "swtext.h"
using namespace sword;


#include "rawtext.h"
using namespace sword;


#include "ztext.h"
using namespace sword;


#include "swcom.h"
using namespace sword;


#include "rawcom.h"
using namespace sword;


#include "zcom.h"
using namespace sword;


#include "swgenbook.h"
using namespace sword;


#include "rawgenbook.h"
#include "treekeyidx.h"
#include "swkey.h"
using namespace sword;

TreeKeyIdx *RawGenBook_getTreeKey(RawGenBook *self){
		return ( (TreeKeyIdx *) ( (SWKey *) (*self) ) );
	}

#include "swld.h"
using namespace sword;


#include "rawld.h"
using namespace sword;


#include "rawld4.h"
using namespace sword;


#include "zld.h"
using namespace sword;


#include <swcomprs.h>
using namespace sword;


#include <lzsscomprs.h>
using namespace sword;


#include <zipcomprs.h>
using namespace sword;


#include "swbuf.h"
using namespace sword;

#ifdef PERL_OBJECT
#define MAGIC_CLASS _wrap_Sword_var::
class _wrap_Sword_var : public CPerlObj {
public:
#else
#define MAGIC_CLASS
#endif
SWIGCLASS_STATIC int swig_magic_readonly(pTHX_ SV *sv, MAGIC *mg) {
    MAGIC_PPERL
    sv = sv; mg = mg;
    croak("Value is read-only.");
    return 0;
}


#ifdef PERL_OBJECT
};
#endif

#ifdef __cplusplus
extern "C" {
#endif
XS(_wrap_SWConfig_filename_set) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        SWConfig *arg1 = (SWConfig *) 0 ;
        SWBuf *arg2 = (SWBuf *) 0 ;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 2) || (items > 2)) {
            SWIG_croak("Usage: SWConfig_filename_set(self,filename);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_SWConfig,0) < 0) {
                SWIG_croak("Type error in argument 1 of SWConfig_filename_set. Expected _p_SWConfig");
            }
        }
        {
            if (SWIG_ConvertPtr(ST(1), (void **) &arg2, SWIGTYPE_p_SWBuf,0) < 0) {
                SWIG_croak("Type error in argument 2 of SWConfig_filename_set. Expected _p_SWBuf");
            }
        }
        if (arg1) (arg1)->filename = *arg2;
        
        
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}


XS(_wrap_SWConfig_filename_get) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        SWConfig *arg1 = (SWConfig *) 0 ;
        SWBuf *result;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 1) || (items > 1)) {
            SWIG_croak("Usage: SWConfig_filename_get(self);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_SWConfig,0) < 0) {
                SWIG_croak("Type error in argument 1 of SWConfig_filename_get. Expected _p_SWConfig");
            }
        }
        result = (SWBuf *)& ((arg1)->filename);
        
        ST(argvi) = sv_newmortal();
        SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_SWBuf,0);
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}


XS(_wrap_SWConfig_Sections_set) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        SWConfig *arg1 = (SWConfig *) 0 ;
        SectionMap arg2 ;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 2) || (items > 2)) {
            SWIG_croak("Usage: SWConfig_Sections_set(self,Sections);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_SWConfig,0) < 0) {
                SWIG_croak("Type error in argument 1 of SWConfig_Sections_set. Expected _p_SWConfig");
            }
        }
        {
            SectionMap * argp;
            if (SWIG_ConvertPtr(ST(1),(void **) &argp, SWIGTYPE_p_SectionMap,0) < 0) {
                SWIG_croak("Type error in argument 2 of SWConfig_Sections_set. Expected _p_SectionMap");
            }
            arg2 = *argp;
        }
        if (arg1) (arg1)->Sections = arg2;
        
        
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}


XS(_wrap_SWConfig_Sections_get) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        SWConfig *arg1 = (SWConfig *) 0 ;
        SectionMap result;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 1) || (items > 1)) {
            SWIG_croak("Usage: SWConfig_Sections_get(self);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_SWConfig,0) < 0) {
                SWIG_croak("Type error in argument 1 of SWConfig_Sections_get. Expected _p_SWConfig");
            }
        }
        result =  ((arg1)->Sections);
        
        {
            SectionMap * resultobj = new SectionMap((SectionMap &)result);
            ST(argvi) = sv_newmortal();
            SWIG_MakePtr(ST(argvi++), (void *) resultobj, SWIGTYPE_p_SectionMap,0);
        }
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}


XS(_wrap_new_SWConfig) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        char *arg1 ;
        SWConfig *result;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 1) || (items > 1)) {
            SWIG_croak("Usage: new_SWConfig(ifilename);");
        }
        if (!SvOK((SV*) ST(0))) arg1 = 0;
        else arg1 = (char *) SvPV(ST(0), PL_na);
        result = (SWConfig *)new SWConfig((char const *)arg1);
        
        ST(argvi) = sv_newmortal();
        SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_SWConfig,0);
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}


XS(_wrap_delete_SWConfig) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        SWConfig *arg1 = (SWConfig *) 0 ;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 1) || (items > 1)) {
            SWIG_croak("Usage: delete_SWConfig(self);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_SWConfig,0) < 0) {
                SWIG_croak("Type error in argument 1 of delete_SWConfig. Expected _p_SWConfig");
            }
        }
        delete arg1;
        
        
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}


XS(_wrap_SWConfig_Load) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        SWConfig *arg1 = (SWConfig *) 0 ;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 1) || (items > 1)) {
            SWIG_croak("Usage: SWConfig_Load(self);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_SWConfig,0) < 0) {
                SWIG_croak("Type error in argument 1 of SWConfig_Load. Expected _p_SWConfig");
            }
        }
        (arg1)->Load();
        
        
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}


XS(_wrap_SWConfig_Save) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        SWConfig *arg1 = (SWConfig *) 0 ;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 1) || (items > 1)) {
            SWIG_croak("Usage: SWConfig_Save(self);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_SWConfig,0) < 0) {
                SWIG_croak("Type error in argument 1 of SWConfig_Save. Expected _p_SWConfig");
            }
        }
        (arg1)->Save();
        
        
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}


XS(_wrap_SWConfig_set) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        SWConfig *arg1 = (SWConfig *) 0 ;
        char *arg2 ;
        char *arg3 ;
        char *arg4 ;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 4) || (items > 4)) {
            SWIG_croak("Usage: SWConfig_set(self,group,entry,value);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_SWConfig,0) < 0) {
                SWIG_croak("Type error in argument 1 of SWConfig_set. Expected _p_SWConfig");
            }
        }
        if (!SvOK((SV*) ST(1))) arg2 = 0;
        else arg2 = (char *) SvPV(ST(1), PL_na);
        if (!SvOK((SV*) ST(2))) arg3 = 0;
        else arg3 = (char *) SvPV(ST(2), PL_na);
        if (!SvOK((SV*) ST(3))) arg4 = 0;
        else arg4 = (char *) SvPV(ST(3), PL_na);
        SWConfig_set(arg1,(char const *)arg2,(char const *)arg3,(char const *)arg4);
        
        
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}


XS(_wrap_SWConfig_get) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        SWConfig *arg1 = (SWConfig *) 0 ;
        char *arg2 ;
        char *arg3 ;
        char *result;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 3) || (items > 3)) {
            SWIG_croak("Usage: SWConfig_get(self,group,entry);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_SWConfig,0) < 0) {
                SWIG_croak("Type error in argument 1 of SWConfig_get. Expected _p_SWConfig");
            }
        }
        if (!SvOK((SV*) ST(1))) arg2 = 0;
        else arg2 = (char *) SvPV(ST(1), PL_na);
        if (!SvOK((SV*) ST(2))) arg3 = 0;
        else arg3 = (char *) SvPV(ST(2), PL_na);
        result = (char *)SWConfig_get(arg1,(char const *)arg2,(char const *)arg3);
        
        ST(argvi) = sv_newmortal();
        if (result) {
            sv_setpv((SV*)ST(argvi++), (char *) result);
        }else {
            sv_setsv((SV*)ST(argvi++), &PL_sv_undef);
        }
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}


XS(_wrap_SWMgr_findConfig) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        char *arg1 ;
        char **arg2 = (char **) 0 ;
        char **arg3 = (char **) 0 ;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 3) || (items > 3)) {
            SWIG_croak("Usage: SWMgr_findConfig(configType,prefixPath,configPath);");
        }
        if (!SvOK((SV*) ST(0))) arg1 = 0;
        else arg1 = (char *) SvPV(ST(0), PL_na);
        {
            if (SWIG_ConvertPtr(ST(1), (void **) &arg2, SWIGTYPE_p_p_char,0) < 0) {
                SWIG_croak("Type error in argument 2 of SWMgr_findConfig. Expected _p_p_char");
            }
        }
        {
            if (SWIG_ConvertPtr(ST(2), (void **) &arg3, SWIGTYPE_p_p_char,0) < 0) {
                SWIG_croak("Type error in argument 3 of SWMgr_findConfig. Expected _p_p_char");
            }
        }
        SWMgr::findConfig(arg1,arg2,arg3);
        
        
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}


XS(_wrap_SWMgr_config_set) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        SWMgr *arg1 = (SWMgr *) 0 ;
        SWConfig *arg2 = (SWConfig *) 0 ;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 2) || (items > 2)) {
            SWIG_croak("Usage: SWMgr_config_set(self,config);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_SWMgr,0) < 0) {
                SWIG_croak("Type error in argument 1 of SWMgr_config_set. Expected _p_SWMgr");
            }
        }
        {
            if (SWIG_ConvertPtr(ST(1), (void **) &arg2, SWIGTYPE_p_SWConfig,0) < 0) {
                SWIG_croak("Type error in argument 2 of SWMgr_config_set. Expected _p_SWConfig");
            }
        }
        if (arg1) (arg1)->config = arg2;
        
        
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}


XS(_wrap_SWMgr_config_get) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        SWMgr *arg1 = (SWMgr *) 0 ;
        SWConfig *result;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 1) || (items > 1)) {
            SWIG_croak("Usage: SWMgr_config_get(self);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_SWMgr,0) < 0) {
                SWIG_croak("Type error in argument 1 of SWMgr_config_get. Expected _p_SWMgr");
            }
        }
        result = (SWConfig *) ((arg1)->config);
        
        ST(argvi) = sv_newmortal();
        SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_SWConfig,0);
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}


XS(_wrap_SWMgr_sysconfig_set) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        SWMgr *arg1 = (SWMgr *) 0 ;
        SWConfig *arg2 = (SWConfig *) 0 ;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 2) || (items > 2)) {
            SWIG_croak("Usage: SWMgr_sysconfig_set(self,sysconfig);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_SWMgr,0) < 0) {
                SWIG_croak("Type error in argument 1 of SWMgr_sysconfig_set. Expected _p_SWMgr");
            }
        }
        {
            if (SWIG_ConvertPtr(ST(1), (void **) &arg2, SWIGTYPE_p_SWConfig,0) < 0) {
                SWIG_croak("Type error in argument 2 of SWMgr_sysconfig_set. Expected _p_SWConfig");
            }
        }
        if (arg1) (arg1)->sysconfig = arg2;
        
        
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}


XS(_wrap_SWMgr_sysconfig_get) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        SWMgr *arg1 = (SWMgr *) 0 ;
        SWConfig *result;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 1) || (items > 1)) {
            SWIG_croak("Usage: SWMgr_sysconfig_get(self);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_SWMgr,0) < 0) {
                SWIG_croak("Type error in argument 1 of SWMgr_sysconfig_get. Expected _p_SWMgr");
            }
        }
        result = (SWConfig *) ((arg1)->sysconfig);
        
        ST(argvi) = sv_newmortal();
        SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_SWConfig,0);
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}


XS(_wrap_SWMgr_Modules_set) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        SWMgr *arg1 = (SWMgr *) 0 ;
        ModMap arg2 ;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 2) || (items > 2)) {
            SWIG_croak("Usage: SWMgr_Modules_set(self,Modules);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_SWMgr,0) < 0) {
                SWIG_croak("Type error in argument 1 of SWMgr_Modules_set. Expected _p_SWMgr");
            }
        }
        {
            ModMap * argp;
            if (SWIG_ConvertPtr(ST(1),(void **) &argp, SWIGTYPE_p_ModMap,0) < 0) {
                SWIG_croak("Type error in argument 2 of SWMgr_Modules_set. Expected _p_ModMap");
            }
            arg2 = *argp;
        }
        if (arg1) (arg1)->Modules = arg2;
        
        
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}


XS(_wrap_SWMgr_Modules_get) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        SWMgr *arg1 = (SWMgr *) 0 ;
        ModMap result;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 1) || (items > 1)) {
            SWIG_croak("Usage: SWMgr_Modules_get(self);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_SWMgr,0) < 0) {
                SWIG_croak("Type error in argument 1 of SWMgr_Modules_get. Expected _p_SWMgr");
            }
        }
        result =  ((arg1)->Modules);
        
        {
            ModMap * resultobj = new ModMap((ModMap &)result);
            ST(argvi) = sv_newmortal();
            SWIG_MakePtr(ST(argvi++), (void *) resultobj, SWIGTYPE_p_ModMap,0);
        }
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}


XS(_wrap_SWMgr_prefixPath_set) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        SWMgr *arg1 = (SWMgr *) 0 ;
        char *arg2 ;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 2) || (items > 2)) {
            SWIG_croak("Usage: SWMgr_prefixPath_set(self,prefixPath);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_SWMgr,0) < 0) {
                SWIG_croak("Type error in argument 1 of SWMgr_prefixPath_set. Expected _p_SWMgr");
            }
        }
        if (!SvOK((SV*) ST(1))) arg2 = 0;
        else arg2 = (char *) SvPV(ST(1), PL_na);
        {
            if (arg1->prefixPath) delete [] arg1->prefixPath;
            if (arg2) {
                arg1->prefixPath = (char *) (new char[strlen(arg2)+1]);
                strcpy((char *) arg1->prefixPath,arg2);
            }else {
                arg1->prefixPath = 0;
            }
        }
        
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}


XS(_wrap_SWMgr_prefixPath_get) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        SWMgr *arg1 = (SWMgr *) 0 ;
        char *result;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 1) || (items > 1)) {
            SWIG_croak("Usage: SWMgr_prefixPath_get(self);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_SWMgr,0) < 0) {
                SWIG_croak("Type error in argument 1 of SWMgr_prefixPath_get. Expected _p_SWMgr");
            }
        }
        result = (char *) ((arg1)->prefixPath);
        
        ST(argvi) = sv_newmortal();
        if (result) {
            sv_setpv((SV*)ST(argvi++), (char *) result);
        }else {
            sv_setsv((SV*)ST(argvi++), &PL_sv_undef);
        }
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}


XS(_wrap_SWMgr_configPath_set) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        SWMgr *arg1 = (SWMgr *) 0 ;
        char *arg2 ;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 2) || (items > 2)) {
            SWIG_croak("Usage: SWMgr_configPath_set(self,configPath);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_SWMgr,0) < 0) {
                SWIG_croak("Type error in argument 1 of SWMgr_configPath_set. Expected _p_SWMgr");
            }
        }
        if (!SvOK((SV*) ST(1))) arg2 = 0;
        else arg2 = (char *) SvPV(ST(1), PL_na);
        {
            if (arg1->configPath) delete [] arg1->configPath;
            if (arg2) {
                arg1->configPath = (char *) (new char[strlen(arg2)+1]);
                strcpy((char *) arg1->configPath,arg2);
            }else {
                arg1->configPath = 0;
            }
        }
        
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}


XS(_wrap_SWMgr_configPath_get) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        SWMgr *arg1 = (SWMgr *) 0 ;
        char *result;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 1) || (items > 1)) {
            SWIG_croak("Usage: SWMgr_configPath_get(self);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_SWMgr,0) < 0) {
                SWIG_croak("Type error in argument 1 of SWMgr_configPath_get. Expected _p_SWMgr");
            }
        }
        result = (char *) ((arg1)->configPath);
        
        ST(argvi) = sv_newmortal();
        if (result) {
            sv_setpv((SV*)ST(argvi++), (char *) result);
        }else {
            sv_setsv((SV*)ST(argvi++), &PL_sv_undef);
        }
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}


XS(_wrap_new_SWMgr__SWIG_0) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        SWConfig *arg1 = (SWConfig *) 0 ;
        SWConfig *arg2 = (SWConfig *) 0 ;
        bool arg3 = (bool) true ;
        SWFilterMgr *arg4 = (SWFilterMgr *) 0 ;
        SWMgr *result;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 0) || (items > 4)) {
            SWIG_croak("Usage: new_SWMgr(iconfig,isysconfig,autoload,filterMgr);");
        }
        if (items > 0) {
            {
                if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_SWConfig,0) < 0) {
                    SWIG_croak("Type error in argument 1 of new_SWMgr. Expected _p_SWConfig");
                }
            }
        }
        if (items > 1) {
            {
                if (SWIG_ConvertPtr(ST(1), (void **) &arg2, SWIGTYPE_p_SWConfig,0) < 0) {
                    SWIG_croak("Type error in argument 2 of new_SWMgr. Expected _p_SWConfig");
                }
            }
        }
        if (items > 2) {
            arg3 = (bool) SvIV(ST(2));
        }
        if (items > 3) {
            {
                if (SWIG_ConvertPtr(ST(3), (void **) &arg4, SWIGTYPE_p_SWFilterMgr,0) < 0) {
                    SWIG_croak("Type error in argument 4 of new_SWMgr. Expected _p_SWFilterMgr");
                }
            }
        }
        result = (SWMgr *)new SWMgr(arg1,arg2,arg3,arg4);
        
        ST(argvi) = sv_newmortal();
        SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_SWMgr,0);
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}


XS(_wrap_new_SWMgr__SWIG_1) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        char *arg1 ;
        bool arg2 = (bool) true ;
        SWFilterMgr *arg3 = (SWFilterMgr *) 0 ;
        SWMgr *result;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 1) || (items > 3)) {
            SWIG_croak("Usage: new_SWMgr(iConfigPath,autoload,filterMgr);");
        }
        if (!SvOK((SV*) ST(0))) arg1 = 0;
        else arg1 = (char *) SvPV(ST(0), PL_na);
        if (items > 1) {
            arg2 = (bool) SvIV(ST(1));
        }
        if (items > 2) {
            {
                if (SWIG_ConvertPtr(ST(2), (void **) &arg3, SWIGTYPE_p_SWFilterMgr,0) < 0) {
                    SWIG_croak("Type error in argument 3 of new_SWMgr. Expected _p_SWFilterMgr");
                }
            }
        }
        result = (SWMgr *)new SWMgr((char const *)arg1,arg2,arg3);
        
        ST(argvi) = sv_newmortal();
        SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_SWMgr,0);
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}


XS(_wrap_new_SWMgr) {
    dXSARGS;
    
    if ((items >= 0) && (items <= 4)) {
        int _v;
        if (items <= 0) {
            (*PL_markstack_ptr++);SWIG_CALLXS(_wrap_new_SWMgr__SWIG_0); return;
        }
        {
            void *tmp;
            if (SWIG_ConvertPtr(ST(0), (void **) &tmp, SWIGTYPE_p_SWConfig, 0) == -1) {
                _v = 0;
            }else {
                _v = 1;
            }
        }
        if (_v) {
            if (items <= 1) {
                (*PL_markstack_ptr++);SWIG_CALLXS(_wrap_new_SWMgr__SWIG_0); return;
            }
            {
                void *tmp;
                if (SWIG_ConvertPtr(ST(1), (void **) &tmp, SWIGTYPE_p_SWConfig, 0) == -1) {
                    _v = 0;
                }else {
                    _v = 1;
                }
            }
            if (_v) {
                if (items <= 2) {
                    (*PL_markstack_ptr++);SWIG_CALLXS(_wrap_new_SWMgr__SWIG_0); return;
                }
                {
                    _v = SvIOK(ST(2)) ? 1 : 0;
                }
                if (_v) {
                    if (items <= 3) {
                        (*PL_markstack_ptr++);SWIG_CALLXS(_wrap_new_SWMgr__SWIG_0); return;
                    }
                    {
                        void *tmp;
                        if (SWIG_ConvertPtr(ST(3), (void **) &tmp, SWIGTYPE_p_SWFilterMgr, 0) == -1) {
                            _v = 0;
                        }else {
                            _v = 1;
                        }
                    }
                    if (_v) {
                        (*PL_markstack_ptr++);SWIG_CALLXS(_wrap_new_SWMgr__SWIG_0); return;
                    }
                }
            }
        }
    }
    if ((items >= 1) && (items <= 3)) {
        int _v;
        {
            _v = SvPOK(ST(0)) ? 1 : 0;
        }
        if (_v) {
            if (items <= 1) {
                (*PL_markstack_ptr++);SWIG_CALLXS(_wrap_new_SWMgr__SWIG_1); return;
            }
            {
                _v = SvIOK(ST(1)) ? 1 : 0;
            }
            if (_v) {
                if (items <= 2) {
                    (*PL_markstack_ptr++);SWIG_CALLXS(_wrap_new_SWMgr__SWIG_1); return;
                }
                {
                    void *tmp;
                    if (SWIG_ConvertPtr(ST(2), (void **) &tmp, SWIGTYPE_p_SWFilterMgr, 0) == -1) {
                        _v = 0;
                    }else {
                        _v = 1;
                    }
                }
                if (_v) {
                    (*PL_markstack_ptr++);SWIG_CALLXS(_wrap_new_SWMgr__SWIG_1); return;
                }
            }
        }
    }
    
    croak("No matching function for overloaded 'new_SWMgr'");
    XSRETURN(0);
}


XS(_wrap_delete_SWMgr) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        SWMgr *arg1 = (SWMgr *) 0 ;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 1) || (items > 1)) {
            SWIG_croak("Usage: delete_SWMgr(self);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_SWMgr,0) < 0) {
                SWIG_croak("Type error in argument 1 of delete_SWMgr. Expected _p_SWMgr");
            }
        }
        delete arg1;
        
        
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}


XS(_wrap_SWMgr_Load) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        SWMgr *arg1 = (SWMgr *) 0 ;
        signed char result;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 1) || (items > 1)) {
            SWIG_croak("Usage: SWMgr_Load(self);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_SWMgr,0) < 0) {
                SWIG_croak("Type error in argument 1 of SWMgr_Load. Expected _p_SWMgr");
            }
        }
        result = (signed char)(arg1)->Load();
        
        ST(argvi) = sv_newmortal();
        sv_setiv(ST(argvi++), (IV) result);
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}


XS(_wrap_SWMgr_setGlobalOption) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        SWMgr *arg1 = (SWMgr *) 0 ;
        char *arg2 ;
        char *arg3 ;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 3) || (items > 3)) {
            SWIG_croak("Usage: SWMgr_setGlobalOption(self,option,value);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_SWMgr,0) < 0) {
                SWIG_croak("Type error in argument 1 of SWMgr_setGlobalOption. Expected _p_SWMgr");
            }
        }
        if (!SvOK((SV*) ST(1))) arg2 = 0;
        else arg2 = (char *) SvPV(ST(1), PL_na);
        if (!SvOK((SV*) ST(2))) arg3 = 0;
        else arg3 = (char *) SvPV(ST(2), PL_na);
        (arg1)->setGlobalOption((char const *)arg2,(char const *)arg3);
        
        
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}


XS(_wrap_SWMgr_getGlobalOption) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        SWMgr *arg1 = (SWMgr *) 0 ;
        char *arg2 ;
        char *result;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 2) || (items > 2)) {
            SWIG_croak("Usage: SWMgr_getGlobalOption(self,option);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_SWMgr,0) < 0) {
                SWIG_croak("Type error in argument 1 of SWMgr_getGlobalOption. Expected _p_SWMgr");
            }
        }
        if (!SvOK((SV*) ST(1))) arg2 = 0;
        else arg2 = (char *) SvPV(ST(1), PL_na);
        result = (char *)(arg1)->getGlobalOption((char const *)arg2);
        
        ST(argvi) = sv_newmortal();
        if (result) {
            sv_setpv((SV*)ST(argvi++), (char *) result);
        }else {
            sv_setsv((SV*)ST(argvi++), &PL_sv_undef);
        }
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}


XS(_wrap_SWMgr_getGlobalOptionTip) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        SWMgr *arg1 = (SWMgr *) 0 ;
        char *arg2 ;
        char *result;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 2) || (items > 2)) {
            SWIG_croak("Usage: SWMgr_getGlobalOptionTip(self,option);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_SWMgr,0) < 0) {
                SWIG_croak("Type error in argument 1 of SWMgr_getGlobalOptionTip. Expected _p_SWMgr");
            }
        }
        if (!SvOK((SV*) ST(1))) arg2 = 0;
        else arg2 = (char *) SvPV(ST(1), PL_na);
        result = (char *)(arg1)->getGlobalOptionTip((char const *)arg2);
        
        ST(argvi) = sv_newmortal();
        if (result) {
            sv_setpv((SV*)ST(argvi++), (char *) result);
        }else {
            sv_setsv((SV*)ST(argvi++), &PL_sv_undef);
        }
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}


XS(_wrap_SWMgr_getGlobalOptions) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        SWMgr *arg1 = (SWMgr *) 0 ;
        StringList result;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 1) || (items > 1)) {
            SWIG_croak("Usage: SWMgr_getGlobalOptions(self);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_SWMgr,0) < 0) {
                SWIG_croak("Type error in argument 1 of SWMgr_getGlobalOptions. Expected _p_SWMgr");
            }
        }
        result = (arg1)->getGlobalOptions();
        
        {
            StringList * resultobj = new StringList((StringList &)result);
            ST(argvi) = sv_newmortal();
            SWIG_MakePtr(ST(argvi++), (void *) resultobj, SWIGTYPE_p_StringList,0);
        }
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}


XS(_wrap_SWMgr_getGlobalOptionValues) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        SWMgr *arg1 = (SWMgr *) 0 ;
        char *arg2 ;
        StringList result;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 2) || (items > 2)) {
            SWIG_croak("Usage: SWMgr_getGlobalOptionValues(self,option);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_SWMgr,0) < 0) {
                SWIG_croak("Type error in argument 1 of SWMgr_getGlobalOptionValues. Expected _p_SWMgr");
            }
        }
        if (!SvOK((SV*) ST(1))) arg2 = 0;
        else arg2 = (char *) SvPV(ST(1), PL_na);
        result = (arg1)->getGlobalOptionValues((char const *)arg2);
        
        {
            StringList * resultobj = new StringList((StringList &)result);
            ST(argvi) = sv_newmortal();
            SWIG_MakePtr(ST(argvi++), (void *) resultobj, SWIGTYPE_p_StringList,0);
        }
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}


XS(_wrap_SWMgr_setCipherKey) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        SWMgr *arg1 = (SWMgr *) 0 ;
        char *arg2 ;
        char *arg3 ;
        signed char result;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 3) || (items > 3)) {
            SWIG_croak("Usage: SWMgr_setCipherKey(self,modName,key);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_SWMgr,0) < 0) {
                SWIG_croak("Type error in argument 1 of SWMgr_setCipherKey. Expected _p_SWMgr");
            }
        }
        if (!SvOK((SV*) ST(1))) arg2 = 0;
        else arg2 = (char *) SvPV(ST(1), PL_na);
        if (!SvOK((SV*) ST(2))) arg3 = 0;
        else arg3 = (char *) SvPV(ST(2), PL_na);
        result = (signed char)(arg1)->setCipherKey((char const *)arg2,(char const *)arg3);
        
        ST(argvi) = sv_newmortal();
        sv_setiv(ST(argvi++), (IV) result);
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}


XS(_wrap_SWMgr_getModule) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        SWMgr *arg1 = (SWMgr *) 0 ;
        char *arg2 ;
        SWModule *result;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 2) || (items > 2)) {
            SWIG_croak("Usage: SWMgr_getModule(self,modName);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_SWMgr,0) < 0) {
                SWIG_croak("Type error in argument 1 of SWMgr_getModule. Expected _p_SWMgr");
            }
        }
        if (!SvOK((SV*) ST(1))) arg2 = 0;
        else arg2 = (char *) SvPV(ST(1), PL_na);
        result = (SWModule *)(arg1)->getModule((char const *)arg2);
        
        ST(argvi) = sv_newmortal();
        SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_SWModule,0);
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}


XS(_wrap_SWMgr_InstallScan) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        SWMgr *arg1 = (SWMgr *) 0 ;
        char *arg2 ;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 2) || (items > 2)) {
            SWIG_croak("Usage: SWMgr_InstallScan(self,dir);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_SWMgr,0) < 0) {
                SWIG_croak("Type error in argument 1 of SWMgr_InstallScan. Expected _p_SWMgr");
            }
        }
        if (!SvOK((SV*) ST(1))) arg2 = 0;
        else arg2 = (char *) SvPV(ST(1), PL_na);
        (arg1)->InstallScan((char const *)arg2);
        
        
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}


XS(_wrap_SWMgr_moduleCount) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        SWMgr *arg1 = (SWMgr *) 0 ;
        int result;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 1) || (items > 1)) {
            SWIG_croak("Usage: SWMgr_moduleCount(self);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_SWMgr,0) < 0) {
                SWIG_croak("Type error in argument 1 of SWMgr_moduleCount. Expected _p_SWMgr");
            }
        }
        result = (int)SWMgr_moduleCount(arg1);
        
        ST(argvi) = sv_newmortal();
        sv_setiv(ST(argvi++), (IV) result);
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}


XS(_wrap_SWMgr_getModuleAt) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        SWMgr *arg1 = (SWMgr *) 0 ;
        int arg2 ;
        SWModule *result;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 2) || (items > 2)) {
            SWIG_croak("Usage: SWMgr_getModuleAt(self,pos);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_SWMgr,0) < 0) {
                SWIG_croak("Type error in argument 1 of SWMgr_getModuleAt. Expected _p_SWMgr");
            }
        }
        arg2 = (int) SvIV(ST(1));
        result = (SWModule *)SWMgr_getModuleAt(arg1,arg2);
        
        ST(argvi) = sv_newmortal();
        SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_SWModule,0);
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}


XS(_wrap_SWModule_terminateSearch_set) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        SWModule *arg1 = (SWModule *) 0 ;
        bool arg2 ;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 2) || (items > 2)) {
            SWIG_croak("Usage: SWModule_terminateSearch_set(self,terminateSearch);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_SWModule,0) < 0) {
                SWIG_croak("Type error in argument 1 of SWModule_terminateSearch_set. Expected _p_SWModule");
            }
        }
        arg2 = (bool) SvIV(ST(1));
        if (arg1) (arg1)->terminateSearch = arg2;
        
        
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}


XS(_wrap_SWModule_terminateSearch_get) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        SWModule *arg1 = (SWModule *) 0 ;
        bool result;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 1) || (items > 1)) {
            SWIG_croak("Usage: SWModule_terminateSearch_get(self);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_SWModule,0) < 0) {
                SWIG_croak("Type error in argument 1 of SWModule_terminateSearch_get. Expected _p_SWModule");
            }
        }
        result = (bool) ((arg1)->terminateSearch);
        
        ST(argvi) = sv_newmortal();
        sv_setiv(ST(argvi++), (IV) result);
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}


XS(_wrap_new_SWModule) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        char *arg1 = (char *) 0 ;
        char *arg2 = (char *) 0 ;
        SWDisplay *arg3 = (SWDisplay *) 0 ;
        char *arg4 = (char *) 0 ;
        SWTextEncoding arg5 = (SWTextEncoding) ENC_UNKNOWN ;
        SWTextDirection arg6 = (SWTextDirection) DIRECTION_LTR ;
        SWTextMarkup arg7 = (SWTextMarkup) FMT_UNKNOWN ;
        char *arg8 = (char *) 0 ;
        SWModule *result;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 0) || (items > 8)) {
            SWIG_croak("Usage: new_SWModule(imodname,imoddesc,idisp,imodtype,encoding,dir,markup,modlang);");
        }
        if (items > 0) {
            if (!SvOK((SV*) ST(0))) arg1 = 0;
            else arg1 = (char *) SvPV(ST(0), PL_na);
        }
        if (items > 1) {
            if (!SvOK((SV*) ST(1))) arg2 = 0;
            else arg2 = (char *) SvPV(ST(1), PL_na);
        }
        if (items > 2) {
            {
                if (SWIG_ConvertPtr(ST(2), (void **) &arg3, SWIGTYPE_p_SWDisplay,0) < 0) {
                    SWIG_croak("Type error in argument 3 of new_SWModule. Expected _p_SWDisplay");
                }
            }
        }
        if (items > 3) {
            if (!SvOK((SV*) ST(3))) arg4 = 0;
            else arg4 = (char *) SvPV(ST(3), PL_na);
        }
        if (items > 4) {
            {
                SWTextEncoding * argp;
                if (SWIG_ConvertPtr(ST(4),(void **) &argp, SWIGTYPE_p_SWTextEncoding,0) < 0) {
                    SWIG_croak("Type error in argument 5 of new_SWModule. Expected _p_SWTextEncoding");
                }
                arg5 = *argp;
            }
        }
        if (items > 5) {
            {
                SWTextDirection * argp;
                if (SWIG_ConvertPtr(ST(5),(void **) &argp, SWIGTYPE_p_SWTextDirection,0) < 0) {
                    SWIG_croak("Type error in argument 6 of new_SWModule. Expected _p_SWTextDirection");
                }
                arg6 = *argp;
            }
        }
        if (items > 6) {
            {
                SWTextMarkup * argp;
                if (SWIG_ConvertPtr(ST(6),(void **) &argp, SWIGTYPE_p_SWTextMarkup,0) < 0) {
                    SWIG_croak("Type error in argument 7 of new_SWModule. Expected _p_SWTextMarkup");
                }
                arg7 = *argp;
            }
        }
        if (items > 7) {
            if (!SvOK((SV*) ST(7))) arg8 = 0;
            else arg8 = (char *) SvPV(ST(7), PL_na);
        }
        result = (SWModule *)new SWModule((char const *)arg1,(char const *)arg2,arg3,arg4,arg5,arg6,arg7,(char const *)arg8);
        
        ST(argvi) = sv_newmortal();
        SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_SWModule,0);
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}


XS(_wrap_SWModule_Error) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        SWModule *arg1 = (SWModule *) 0 ;
        char result;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 1) || (items > 1)) {
            SWIG_croak("Usage: SWModule_Error(self);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_SWModule,0) < 0) {
                SWIG_croak("Type error in argument 1 of SWModule_Error. Expected _p_SWModule");
            }
        }
        result = (char)(arg1)->Error();
        
        ST(argvi) = sv_newmortal();
        sv_setpvn((SV*)ST(argvi++), &result, 1);
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}


XS(_wrap_SWModule_isUnicode) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        SWModule *arg1 = (SWModule *) 0 ;
        bool result;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 1) || (items > 1)) {
            SWIG_croak("Usage: SWModule_isUnicode(self);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_SWModule,0) < 0) {
                SWIG_croak("Type error in argument 1 of SWModule_isUnicode. Expected _p_SWModule");
            }
        }
        result = (bool)((SWModule const *)arg1)->isUnicode();
        
        ST(argvi) = sv_newmortal();
        sv_setiv(ST(argvi++), (IV) result);
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}


XS(_wrap_SWModule_getConfig) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        SWModule *arg1 = (SWModule *) 0 ;
        ConfigEntMap *result;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 1) || (items > 1)) {
            SWIG_croak("Usage: SWModule_getConfig(self);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_SWModule,0) < 0) {
                SWIG_croak("Type error in argument 1 of SWModule_getConfig. Expected _p_SWModule");
            }
        }
        {
            ConfigEntMap const &_result_ref = ((SWModule const *)arg1)->getConfig();
            result = (ConfigEntMap *) &_result_ref;
        }
        
        ST(argvi) = sv_newmortal();
        SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_ConfigEntMap,0);
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}


XS(_wrap_SWModule_getConfigEntry) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        SWModule *arg1 = (SWModule *) 0 ;
        char *arg2 ;
        char *result;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 2) || (items > 2)) {
            SWIG_croak("Usage: SWModule_getConfigEntry(self,key);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_SWModule,0) < 0) {
                SWIG_croak("Type error in argument 1 of SWModule_getConfigEntry. Expected _p_SWModule");
            }
        }
        if (!SvOK((SV*) ST(1))) arg2 = 0;
        else arg2 = (char *) SvPV(ST(1), PL_na);
        result = (char *)((SWModule const *)arg1)->getConfigEntry((char const *)arg2);
        
        ST(argvi) = sv_newmortal();
        if (result) {
            sv_setpv((SV*)ST(argvi++), (char *) result);
        }else {
            sv_setsv((SV*)ST(argvi++), &PL_sv_undef);
        }
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}


XS(_wrap_SWModule_SetKey) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        SWModule *arg1 = (SWModule *) 0 ;
        SWKey *arg2 = (SWKey *) 0 ;
        char result;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 2) || (items > 2)) {
            SWIG_croak("Usage: SWModule_SetKey(self,ikey);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_SWModule,0) < 0) {
                SWIG_croak("Type error in argument 1 of SWModule_SetKey. Expected _p_SWModule");
            }
        }
        {
            if (SWIG_ConvertPtr(ST(1), (void **) &arg2, SWIGTYPE_p_SWKey,0) < 0) {
                SWIG_croak("Type error in argument 2 of SWModule_SetKey. Expected _p_SWKey");
            }
        }
        result = (char)(arg1)->SetKey((SWKey const *)arg2);
        
        ST(argvi) = sv_newmortal();
        sv_setpvn((SV*)ST(argvi++), &result, 1);
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}


XS(_wrap_SWModule_Key) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        SWModule *arg1 = (SWModule *) 0 ;
        SWKey *result;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 1) || (items > 1)) {
            SWIG_croak("Usage: SWModule_Key(self);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_SWModule,0) < 0) {
                SWIG_croak("Type error in argument 1 of SWModule_Key. Expected _p_SWModule");
            }
        }
        {
            SWKey &_result_ref = ((SWModule const *)arg1)->Key();
            result = (SWKey *) &_result_ref;
        }
        
        ST(argvi) = sv_newmortal();
        SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_SWKey,0);
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}


XS(_wrap_SWModule_CreateKey) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        SWModule *arg1 = (SWModule *) 0 ;
        SWKey *result;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 1) || (items > 1)) {
            SWIG_croak("Usage: SWModule_CreateKey(self);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_SWModule,0) < 0) {
                SWIG_croak("Type error in argument 1 of SWModule_CreateKey. Expected _p_SWModule");
            }
        }
        result = (SWKey *)(arg1)->CreateKey();
        
        ST(argvi) = sv_newmortal();
        SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_SWKey,0);
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}


XS(_wrap_SWModule_KeyText) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        SWModule *arg1 = (SWModule *) 0 ;
        char *arg2 = (char *) 0 ;
        char *result;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 1) || (items > 2)) {
            SWIG_croak("Usage: SWModule_KeyText(self,imodtype);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_SWModule,0) < 0) {
                SWIG_croak("Type error in argument 1 of SWModule_KeyText. Expected _p_SWModule");
            }
        }
        if (items > 1) {
            if (!SvOK((SV*) ST(1))) arg2 = 0;
            else arg2 = (char *) SvPV(ST(1), PL_na);
        }
        result = (char *)(arg1)->KeyText((char const *)arg2);
        
        ST(argvi) = sv_newmortal();
        if (result) {
            sv_setpv((SV*)ST(argvi++), (char *) result);
        }else {
            sv_setsv((SV*)ST(argvi++), &PL_sv_undef);
        }
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}


XS(_wrap_SWModule_Display) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        SWModule *arg1 = (SWModule *) 0 ;
        char result;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 1) || (items > 1)) {
            SWIG_croak("Usage: SWModule_Display(self);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_SWModule,0) < 0) {
                SWIG_croak("Type error in argument 1 of SWModule_Display. Expected _p_SWModule");
            }
        }
        result = (char)(arg1)->Display();
        
        ST(argvi) = sv_newmortal();
        sv_setpvn((SV*)ST(argvi++), &result, 1);
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}


XS(_wrap_SWModule_nullPercent) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        char arg1 ;
        void *arg2 = (void *) 0 ;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 2) || (items > 2)) {
            SWIG_croak("Usage: SWModule_nullPercent(percent,userData);");
        }
        arg1 = (char) *SvPV(ST(0),PL_na);
        {
            if (SWIG_ConvertPtr(ST(1), (void **) &arg2, 0,0) < 0) {
                SWIG_croak("Type error in argument 2 of SWModule_nullPercent. Expected _p_void");
            }
        }
        SWModule::nullPercent(arg1,arg2);
        
        
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}


XS(_wrap_SWModule_Search) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        SWModule *arg1 = (SWModule *) 0 ;
        char *arg2 ;
        int arg3 = (int) 0 ;
        int arg4 = (int) 0 ;
        SWKey *arg5 = (SWKey *) 0 ;
        bool *arg6 = (bool *) 0 ;
        void (*arg7)(char,void *) = (void (*)(char,void *)) &SWModule::nullPercent ;
        void *arg8 = (void *) 0 ;
        ListKey *result;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 2) || (items > 8)) {
            SWIG_croak("Usage: SWModule_Search(self,istr,searchType,flags,scope,justCheckIfSupported,percent,percentUserData);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_SWModule,0) < 0) {
                SWIG_croak("Type error in argument 1 of SWModule_Search. Expected _p_SWModule");
            }
        }
        if (!SvOK((SV*) ST(1))) arg2 = 0;
        else arg2 = (char *) SvPV(ST(1), PL_na);
        if (items > 2) {
            arg3 = (int) SvIV(ST(2));
        }
        if (items > 3) {
            arg4 = (int) SvIV(ST(3));
        }
        if (items > 4) {
            {
                if (SWIG_ConvertPtr(ST(4), (void **) &arg5, SWIGTYPE_p_SWKey,0) < 0) {
                    SWIG_croak("Type error in argument 5 of SWModule_Search. Expected _p_SWKey");
                }
            }
        }
        if (items > 5) {
            {
                if (SWIG_ConvertPtr(ST(5), (void **) &arg6, SWIGTYPE_p_bool,0) < 0) {
                    SWIG_croak("Type error in argument 6 of SWModule_Search. Expected _p_bool");
                }
            }
        }
        if (items > 6) {
            {
                if (SWIG_ConvertPtr(ST(6), (void **) &arg7, SWIGTYPE_p_f_char_p_void__void,0) < 0) {
                    SWIG_croak("Type error in argument 7 of SWModule_Search. Expected _p_f_char_p_void__void");
                }
            }
        }
        if (items > 7) {
            {
                if (SWIG_ConvertPtr(ST(7), (void **) &arg8, 0,0) < 0) {
                    SWIG_croak("Type error in argument 8 of SWModule_Search. Expected _p_void");
                }
            }
        }
        {
            ListKey &_result_ref = (arg1)->Search((char const *)arg2,arg3,arg4,arg5,arg6,arg7,arg8);
            result = (ListKey *) &_result_ref;
        }
        
        ST(argvi) = sv_newmortal();
        SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_ListKey,0);
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}


XS(_wrap_SWModule_createSearchFramework) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        SWModule *arg1 = (SWModule *) 0 ;
        signed char result;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 1) || (items > 1)) {
            SWIG_croak("Usage: SWModule_createSearchFramework(self);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_SWModule,0) < 0) {
                SWIG_croak("Type error in argument 1 of SWModule_createSearchFramework. Expected _p_SWModule");
            }
        }
        result = (signed char)(arg1)->createSearchFramework();
        
        ST(argvi) = sv_newmortal();
        sv_setiv(ST(argvi++), (IV) result);
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}


XS(_wrap_SWModule_hasSearchFramework) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        SWModule *arg1 = (SWModule *) 0 ;
        bool result;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 1) || (items > 1)) {
            SWIG_croak("Usage: SWModule_hasSearchFramework(self);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_SWModule,0) < 0) {
                SWIG_croak("Type error in argument 1 of SWModule_hasSearchFramework. Expected _p_SWModule");
            }
        }
        result = (bool)(arg1)->hasSearchFramework();
        
        ST(argvi) = sv_newmortal();
        sv_setiv(ST(argvi++), (IV) result);
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}


XS(_wrap_SWModule_isSearchOptimallySupported) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        SWModule *arg1 = (SWModule *) 0 ;
        char *arg2 ;
        int arg3 ;
        int arg4 ;
        SWKey *arg5 = (SWKey *) 0 ;
        bool result;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 5) || (items > 5)) {
            SWIG_croak("Usage: SWModule_isSearchOptimallySupported(self,istr,searchType,flags,scope);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_SWModule,0) < 0) {
                SWIG_croak("Type error in argument 1 of SWModule_isSearchOptimallySupported. Expected _p_SWModule");
            }
        }
        if (!SvOK((SV*) ST(1))) arg2 = 0;
        else arg2 = (char *) SvPV(ST(1), PL_na);
        arg3 = (int) SvIV(ST(2));
        arg4 = (int) SvIV(ST(3));
        {
            if (SWIG_ConvertPtr(ST(4), (void **) &arg5, SWIGTYPE_p_SWKey,0) < 0) {
                SWIG_croak("Type error in argument 5 of SWModule_isSearchOptimallySupported. Expected _p_SWKey");
            }
        }
        result = (bool)(arg1)->isSearchOptimallySupported((char const *)arg2,arg3,arg4,arg5);
        
        ST(argvi) = sv_newmortal();
        sv_setiv(ST(argvi++), (IV) result);
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}


XS(_wrap_SWModule_next) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        SWModule *arg1 = (SWModule *) 0 ;
        bool result;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 1) || (items > 1)) {
            SWIG_croak("Usage: SWModule_next(self);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_SWModule,0) < 0) {
                SWIG_croak("Type error in argument 1 of SWModule_next. Expected _p_SWModule");
            }
        }
        result = (bool)SWModule_next(arg1);
        
        ST(argvi) = sv_newmortal();
        sv_setiv(ST(argvi++), (IV) result);
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}


XS(_wrap_SWModule_prev) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        SWModule *arg1 = (SWModule *) 0 ;
        bool result;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 1) || (items > 1)) {
            SWIG_croak("Usage: SWModule_prev(self);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_SWModule,0) < 0) {
                SWIG_croak("Type error in argument 1 of SWModule_prev. Expected _p_SWModule");
            }
        }
        result = (bool)SWModule_prev(arg1);
        
        ST(argvi) = sv_newmortal();
        sv_setiv(ST(argvi++), (IV) result);
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}


XS(_wrap_SWModule_inc) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        SWModule *arg1 = (SWModule *) 0 ;
        int arg2 ;
        bool result;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 2) || (items > 2)) {
            SWIG_croak("Usage: SWModule_inc(self,howFar);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_SWModule,0) < 0) {
                SWIG_croak("Type error in argument 1 of SWModule_inc. Expected _p_SWModule");
            }
        }
        arg2 = (int) SvIV(ST(1));
        result = (bool)SWModule_inc(arg1,arg2);
        
        ST(argvi) = sv_newmortal();
        sv_setiv(ST(argvi++), (IV) result);
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}


XS(_wrap_SWModule_dec) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        SWModule *arg1 = (SWModule *) 0 ;
        int arg2 ;
        bool result;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 2) || (items > 2)) {
            SWIG_croak("Usage: SWModule_dec(self,howFar);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_SWModule,0) < 0) {
                SWIG_croak("Type error in argument 1 of SWModule_dec. Expected _p_SWModule");
            }
        }
        arg2 = (int) SvIV(ST(1));
        result = (bool)SWModule_dec(arg1,arg2);
        
        ST(argvi) = sv_newmortal();
        sv_setiv(ST(argvi++), (IV) result);
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}


XS(_wrap_SWModule_setPosition) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        SWModule *arg1 = (SWModule *) 0 ;
        SwigValueWrapper< SW_POSITION > arg2 ;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 2) || (items > 2)) {
            SWIG_croak("Usage: SWModule_setPosition(self,pos);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_SWModule,0) < 0) {
                SWIG_croak("Type error in argument 1 of SWModule_setPosition. Expected _p_SWModule");
            }
        }
        {
            SW_POSITION * argp;
            if (SWIG_ConvertPtr(ST(1),(void **) &argp, SWIGTYPE_p_SW_POSITION,0) < 0) {
                SWIG_croak("Type error in argument 2 of SWModule_setPosition. Expected _p_SW_POSITION");
            }
            arg2 = *argp;
        }
        SWModule_setPosition(arg1,arg2);
        
        
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}


XS(_wrap_SWModule_top) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        SWModule *arg1 = (SWModule *) 0 ;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 1) || (items > 1)) {
            SWIG_croak("Usage: SWModule_top(self);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_SWModule,0) < 0) {
                SWIG_croak("Type error in argument 1 of SWModule_top. Expected _p_SWModule");
            }
        }
        SWModule_top(arg1);
        
        
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}


XS(_wrap_SWModule_bottom) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        SWModule *arg1 = (SWModule *) 0 ;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 1) || (items > 1)) {
            SWIG_croak("Usage: SWModule_bottom(self);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_SWModule,0) < 0) {
                SWIG_croak("Type error in argument 1 of SWModule_bottom. Expected _p_SWModule");
            }
        }
        SWModule_bottom(arg1);
        
        
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}


XS(_wrap_SWModule_text) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        SWModule *arg1 = (SWModule *) 0 ;
        char *result;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 1) || (items > 1)) {
            SWIG_croak("Usage: SWModule_text(self);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_SWModule,0) < 0) {
                SWIG_croak("Type error in argument 1 of SWModule_text. Expected _p_SWModule");
            }
        }
        result = (char *)SWModule_text(arg1);
        
        ST(argvi) = sv_newmortal();
        if (result) {
            sv_setpv((SV*)ST(argvi++), (char *) result);
        }else {
            sv_setsv((SV*)ST(argvi++), &PL_sv_undef);
        }
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}


XS(_wrap_SWModule_StripText) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        SWModule *arg1 = (SWModule *) 0 ;
        char *result;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 1) || (items > 1)) {
            SWIG_croak("Usage: SWModule_StripText(self);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_SWModule,0) < 0) {
                SWIG_croak("Type error in argument 1 of SWModule_StripText. Expected _p_SWModule");
            }
        }
        result = (char *)SWModule_StripText(arg1);
        
        ST(argvi) = sv_newmortal();
        if (result) {
            sv_setpv((SV*)ST(argvi++), (char *) result);
        }else {
            sv_setsv((SV*)ST(argvi++), &PL_sv_undef);
        }
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}


XS(_wrap_SWModule_getRawEntry) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        SWModule *arg1 = (SWModule *) 0 ;
        char *result;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 1) || (items > 1)) {
            SWIG_croak("Usage: SWModule_getRawEntry(self);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_SWModule,0) < 0) {
                SWIG_croak("Type error in argument 1 of SWModule_getRawEntry. Expected _p_SWModule");
            }
        }
        result = (char *)(arg1)->getRawEntry();
        
        ST(argvi) = sv_newmortal();
        if (result) {
            sv_setpv((SV*)ST(argvi++), (char *) result);
        }else {
            sv_setsv((SV*)ST(argvi++), &PL_sv_undef);
        }
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}


XS(_wrap_SWModule_setSkipConsecutiveLinks) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        SWModule *arg1 = (SWModule *) 0 ;
        bool arg2 ;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 2) || (items > 2)) {
            SWIG_croak("Usage: SWModule_setSkipConsecutiveLinks(self,val);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_SWModule,0) < 0) {
                SWIG_croak("Type error in argument 1 of SWModule_setSkipConsecutiveLinks. Expected _p_SWModule");
            }
        }
        arg2 = (bool) SvIV(ST(1));
        (arg1)->setSkipConsecutiveLinks(arg2);
        
        
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}


XS(_wrap_SWModule_getSkipConsecutiveLinks) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        SWModule *arg1 = (SWModule *) 0 ;
        bool result;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 1) || (items > 1)) {
            SWIG_croak("Usage: SWModule_getSkipConsecutiveLinks(self);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_SWModule,0) < 0) {
                SWIG_croak("Type error in argument 1 of SWModule_getSkipConsecutiveLinks. Expected _p_SWModule");
            }
        }
        result = (bool)(arg1)->getSkipConsecutiveLinks();
        
        ST(argvi) = sv_newmortal();
        sv_setiv(ST(argvi++), (IV) result);
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}


XS(_wrap_SWModule_getEntryAttributes) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        SWModule *arg1 = (SWModule *) 0 ;
        AttributeTypeList *result;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 1) || (items > 1)) {
            SWIG_croak("Usage: SWModule_getEntryAttributes(self);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_SWModule,0) < 0) {
                SWIG_croak("Type error in argument 1 of SWModule_getEntryAttributes. Expected _p_SWModule");
            }
        }
        {
            AttributeTypeList &_result_ref = ((SWModule const *)arg1)->getEntryAttributes();
            result = (AttributeTypeList *) &_result_ref;
        }
        
        ST(argvi) = sv_newmortal();
        SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_AttributeTypeList,0);
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}


XS(_wrap_SWModule_processEntryAttributes) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        SWModule *arg1 = (SWModule *) 0 ;
        bool arg2 ;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 2) || (items > 2)) {
            SWIG_croak("Usage: SWModule_processEntryAttributes(self,val);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_SWModule,0) < 0) {
                SWIG_croak("Type error in argument 1 of SWModule_processEntryAttributes. Expected _p_SWModule");
            }
        }
        arg2 = (bool) SvIV(ST(1));
        ((SWModule const *)arg1)->processEntryAttributes(arg2);
        
        
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}


XS(_wrap_SWModule_isProcessEntryAttributes) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        SWModule *arg1 = (SWModule *) 0 ;
        bool result;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 1) || (items > 1)) {
            SWIG_croak("Usage: SWModule_isProcessEntryAttributes(self);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_SWModule,0) < 0) {
                SWIG_croak("Type error in argument 1 of SWModule_isProcessEntryAttributes. Expected _p_SWModule");
            }
        }
        result = (bool)((SWModule const *)arg1)->isProcessEntryAttributes();
        
        ST(argvi) = sv_newmortal();
        sv_setiv(ST(argvi++), (IV) result);
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}


XS(_wrap_SWModule_Name) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        SWModule *arg1 = (SWModule *) 0 ;
        char *arg2 = (char *) 0 ;
        char *result;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 1) || (items > 2)) {
            SWIG_croak("Usage: SWModule_Name(self,imodname);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_SWModule,0) < 0) {
                SWIG_croak("Type error in argument 1 of SWModule_Name. Expected _p_SWModule");
            }
        }
        if (items > 1) {
            if (!SvOK((SV*) ST(1))) arg2 = 0;
            else arg2 = (char *) SvPV(ST(1), PL_na);
        }
        result = (char *)(arg1)->Name((char const *)arg2);
        
        ST(argvi) = sv_newmortal();
        if (result) {
            sv_setpv((SV*)ST(argvi++), (char *) result);
        }else {
            sv_setsv((SV*)ST(argvi++), &PL_sv_undef);
        }
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}


XS(_wrap_SWModule_Description) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        SWModule *arg1 = (SWModule *) 0 ;
        char *arg2 = (char *) 0 ;
        char *result;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 1) || (items > 2)) {
            SWIG_croak("Usage: SWModule_Description(self,imoddesc);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_SWModule,0) < 0) {
                SWIG_croak("Type error in argument 1 of SWModule_Description. Expected _p_SWModule");
            }
        }
        if (items > 1) {
            if (!SvOK((SV*) ST(1))) arg2 = 0;
            else arg2 = (char *) SvPV(ST(1), PL_na);
        }
        result = (char *)(arg1)->Description((char const *)arg2);
        
        ST(argvi) = sv_newmortal();
        if (result) {
            sv_setpv((SV*)ST(argvi++), (char *) result);
        }else {
            sv_setsv((SV*)ST(argvi++), &PL_sv_undef);
        }
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}


XS(_wrap_SWModule_Type) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        SWModule *arg1 = (SWModule *) 0 ;
        char *arg2 = (char *) 0 ;
        char *result;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 1) || (items > 2)) {
            SWIG_croak("Usage: SWModule_Type(self,imodtype);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_SWModule,0) < 0) {
                SWIG_croak("Type error in argument 1 of SWModule_Type. Expected _p_SWModule");
            }
        }
        if (items > 1) {
            if (!SvOK((SV*) ST(1))) arg2 = 0;
            else arg2 = (char *) SvPV(ST(1), PL_na);
        }
        result = (char *)(arg1)->Type((char const *)arg2);
        
        ST(argvi) = sv_newmortal();
        if (result) {
            sv_setpv((SV*)ST(argvi++), (char *) result);
        }else {
            sv_setsv((SV*)ST(argvi++), &PL_sv_undef);
        }
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}


XS(_wrap_SWModule_Direction) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        SWModule *arg1 = (SWModule *) 0 ;
        signed char arg2 = (signed char) -1 ;
        char result;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 1) || (items > 2)) {
            SWIG_croak("Usage: SWModule_Direction(self,newdir);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_SWModule,0) < 0) {
                SWIG_croak("Type error in argument 1 of SWModule_Direction. Expected _p_SWModule");
            }
        }
        if (items > 1) {
            arg2 = (signed char) SvIV(ST(1));
        }
        result = (char)(arg1)->Direction(arg2);
        
        ST(argvi) = sv_newmortal();
        sv_setpvn((SV*)ST(argvi++), &result, 1);
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}


XS(_wrap_SWModule_Encoding) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        SWModule *arg1 = (SWModule *) 0 ;
        signed char arg2 = (signed char) -1 ;
        char result;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 1) || (items > 2)) {
            SWIG_croak("Usage: SWModule_Encoding(self,enc);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_SWModule,0) < 0) {
                SWIG_croak("Type error in argument 1 of SWModule_Encoding. Expected _p_SWModule");
            }
        }
        if (items > 1) {
            arg2 = (signed char) SvIV(ST(1));
        }
        result = (char)(arg1)->Encoding(arg2);
        
        ST(argvi) = sv_newmortal();
        sv_setpvn((SV*)ST(argvi++), &result, 1);
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}


XS(_wrap_SWModule_Markup) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        SWModule *arg1 = (SWModule *) 0 ;
        signed char arg2 = (signed char) -1 ;
        char result;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 1) || (items > 2)) {
            SWIG_croak("Usage: SWModule_Markup(self,enc);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_SWModule,0) < 0) {
                SWIG_croak("Type error in argument 1 of SWModule_Markup. Expected _p_SWModule");
            }
        }
        if (items > 1) {
            arg2 = (signed char) SvIV(ST(1));
        }
        result = (char)(arg1)->Markup(arg2);
        
        ST(argvi) = sv_newmortal();
        sv_setpvn((SV*)ST(argvi++), &result, 1);
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}


XS(_wrap_SWModule_Lang) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        SWModule *arg1 = (SWModule *) 0 ;
        char *arg2 = (char *) 0 ;
        char *result;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 1) || (items > 2)) {
            SWIG_croak("Usage: SWModule_Lang(self,imodlang);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_SWModule,0) < 0) {
                SWIG_croak("Type error in argument 1 of SWModule_Lang. Expected _p_SWModule");
            }
        }
        if (items > 1) {
            if (!SvOK((SV*) ST(1))) arg2 = 0;
            else arg2 = (char *) SvPV(ST(1), PL_na);
        }
        result = (char *)(arg1)->Lang((char const *)arg2);
        
        ST(argvi) = sv_newmortal();
        if (result) {
            sv_setpv((SV*)ST(argvi++), (char *) result);
        }else {
            sv_setsv((SV*)ST(argvi++), &PL_sv_undef);
        }
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}


XS(_wrap_SWModule_isWritable) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        SWModule *arg1 = (SWModule *) 0 ;
        bool result;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 1) || (items > 1)) {
            SWIG_croak("Usage: SWModule_isWritable(self);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_SWModule,0) < 0) {
                SWIG_croak("Type error in argument 1 of SWModule_isWritable. Expected _p_SWModule");
            }
        }
        result = (bool)(arg1)->isWritable();
        
        ST(argvi) = sv_newmortal();
        sv_setiv(ST(argvi++), (IV) result);
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}


XS(_wrap_SWModule_createModule) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        char *arg1 ;
        signed char result;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 1) || (items > 1)) {
            SWIG_croak("Usage: SWModule_createModule(char const *);");
        }
        if (!SvOK((SV*) ST(0))) arg1 = 0;
        else arg1 = (char *) SvPV(ST(0), PL_na);
        result = (signed char)SWModule::createModule((char const *)arg1);
        
        ST(argvi) = sv_newmortal();
        sv_setiv(ST(argvi++), (IV) result);
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}


XS(_wrap_SWModule_setEntry) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        SWModule *arg1 = (SWModule *) 0 ;
        char *arg2 ;
        long arg3 ;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 3) || (items > 3)) {
            SWIG_croak("Usage: SWModule_setEntry(self,inbuf,len);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_SWModule,0) < 0) {
                SWIG_croak("Type error in argument 1 of SWModule_setEntry. Expected _p_SWModule");
            }
        }
        if (!SvOK((SV*) ST(1))) arg2 = 0;
        else arg2 = (char *) SvPV(ST(1), PL_na);
        arg3 = (long) SvIV(ST(2));
        (arg1)->setEntry((char const *)arg2,arg3);
        
        
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}


XS(_wrap_SWModule_deleteEntry) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        SWModule *arg1 = (SWModule *) 0 ;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 1) || (items > 1)) {
            SWIG_croak("Usage: SWModule_deleteEntry(self);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_SWModule,0) < 0) {
                SWIG_croak("Type error in argument 1 of SWModule_deleteEntry. Expected _p_SWModule");
            }
        }
        (arg1)->deleteEntry();
        
        
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}


XS(_wrap_SWModule_write) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        SWModule *arg1 = (SWModule *) 0 ;
        char *arg2 ;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 2) || (items > 2)) {
            SWIG_croak("Usage: SWModule_write(self,text);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_SWModule,0) < 0) {
                SWIG_croak("Type error in argument 1 of SWModule_write. Expected _p_SWModule");
            }
        }
        if (!SvOK((SV*) ST(1))) arg2 = 0;
        else arg2 = (char *) SvPV(ST(1), PL_na);
        SWModule_write(arg1,(char const *)arg2);
        
        
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}


XS(_wrap_SWModule_writeLink) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        SWModule *arg1 = (SWModule *) 0 ;
        SWKey *arg2 = (SWKey *) 0 ;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 2) || (items > 2)) {
            SWIG_croak("Usage: SWModule_writeLink(self,key);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_SWModule,0) < 0) {
                SWIG_croak("Type error in argument 1 of SWModule_writeLink. Expected _p_SWModule");
            }
        }
        {
            if (SWIG_ConvertPtr(ST(1), (void **) &arg2, SWIGTYPE_p_SWKey,0) < 0) {
                SWIG_croak("Type error in argument 2 of SWModule_writeLink. Expected _p_SWKey");
            }
        }
        SWModule_writeLink(arg1,(SWKey const *)arg2);
        
        
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}


XS(_wrap_delete_SWModule) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        SWModule *arg1 = (SWModule *) 0 ;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 1) || (items > 1)) {
            SWIG_croak("Usage: delete_SWModule(self);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_SWModule,0) < 0) {
                SWIG_croak("Type error in argument 1 of delete_SWModule. Expected _p_SWModule");
            }
        }
        delete arg1;
        
        
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}


XS(_wrap_new_SW_POSITION) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        char arg1 ;
        SW_POSITION *result;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 1) || (items > 1)) {
            SWIG_croak("Usage: new_SW_POSITION(ipos);");
        }
        arg1 = (char) *SvPV(ST(0),PL_na);
        result = (SW_POSITION *)new SW_POSITION(arg1);
        
        ST(argvi) = sv_newmortal();
        SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_SW_POSITION,0);
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}


XS(_wrap_delete_SW_POSITION) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        SW_POSITION *arg1 = (SW_POSITION *) 0 ;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 1) || (items > 1)) {
            SWIG_croak("Usage: delete_SW_POSITION(self);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_SW_POSITION,0) < 0) {
                SWIG_croak("Type error in argument 1 of delete_SW_POSITION. Expected _p_SW_POSITION");
            }
        }
        delete arg1;
        
        
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}


XS(_wrap_new_SWKey__SWIG_0) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        char *arg1 = (char *) 0 ;
        SWKey *result;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 0) || (items > 1)) {
            SWIG_croak("Usage: new_SWKey(ikey);");
        }
        if (items > 0) {
            if (!SvOK((SV*) ST(0))) arg1 = 0;
            else arg1 = (char *) SvPV(ST(0), PL_na);
        }
        result = (SWKey *)new SWKey((char const *)arg1);
        
        ST(argvi) = sv_newmortal();
        SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_SWKey,0);
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}


XS(_wrap_new_SWKey__SWIG_1) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        SWKey *arg1 = 0 ;
        SWKey *result;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 1) || (items > 1)) {
            SWIG_croak("Usage: new_SWKey(k);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_SWKey,0) < 0) {
                SWIG_croak("Type error in argument 1 of new_SWKey. Expected _p_SWKey");
            }
        }
        result = (SWKey *)new SWKey((SWKey const &)*arg1);
        
        ST(argvi) = sv_newmortal();
        SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_SWKey,0);
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}


XS(_wrap_new_SWKey) {
    dXSARGS;
    
    if ((items >= 0) && (items <= 1)) {
        int _v;
        if (items <= 0) {
            (*PL_markstack_ptr++);SWIG_CALLXS(_wrap_new_SWKey__SWIG_0); return;
        }
        {
            _v = SvPOK(ST(0)) ? 1 : 0;
        }
        if (_v) {
            (*PL_markstack_ptr++);SWIG_CALLXS(_wrap_new_SWKey__SWIG_0); return;
        }
    }
    if (items == 1) {
        int _v;
        {
            void *tmp;
            if (SWIG_ConvertPtr(ST(0), (void **) &tmp, SWIGTYPE_p_SWKey, 0) == -1) {
                _v = 0;
            }else {
                _v = 1;
            }
        }
        if (_v) {
            (*PL_markstack_ptr++);SWIG_CALLXS(_wrap_new_SWKey__SWIG_1); return;
        }
    }
    
    croak("No matching function for overloaded 'new_SWKey'");
    XSRETURN(0);
}


XS(_wrap_SWKey_clone) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        SWKey *arg1 = (SWKey *) 0 ;
        SWKey *result;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 1) || (items > 1)) {
            SWIG_croak("Usage: SWKey_clone(self);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_SWKey,0) < 0) {
                SWIG_croak("Type error in argument 1 of SWKey_clone. Expected _p_SWKey");
            }
        }
        result = (SWKey *)((SWKey const *)arg1)->clone();
        
        ST(argvi) = sv_newmortal();
        SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_SWKey,0);
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}


XS(_wrap_delete_SWKey) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        SWKey *arg1 = (SWKey *) 0 ;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 1) || (items > 1)) {
            SWIG_croak("Usage: delete_SWKey(self);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_SWKey,0) < 0) {
                SWIG_croak("Type error in argument 1 of delete_SWKey. Expected _p_SWKey");
            }
        }
        delete arg1;
        
        
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}


XS(_wrap_SWKey_Persist) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        SWKey *arg1 = (SWKey *) 0 ;
        char result;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 1) || (items > 1)) {
            SWIG_croak("Usage: SWKey_Persist(self);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_SWKey,0) < 0) {
                SWIG_croak("Type error in argument 1 of SWKey_Persist. Expected _p_SWKey");
            }
        }
        result = (char)((SWKey const *)arg1)->Persist();
        
        ST(argvi) = sv_newmortal();
        sv_setpvn((SV*)ST(argvi++), &result, 1);
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}


XS(_wrap_SWKey_setPersist) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        SWKey *arg1 = (SWKey *) 0 ;
        signed char arg2 ;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 2) || (items > 2)) {
            SWIG_croak("Usage: SWKey_setPersist(self,persists);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_SWKey,0) < 0) {
                SWIG_croak("Type error in argument 1 of SWKey_setPersist. Expected _p_SWKey");
            }
        }
        arg2 = (signed char) SvIV(ST(1));
        SWKey_setPersist(arg1,arg2);
        
        
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}


XS(_wrap_SWKey_Error) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        SWKey *arg1 = (SWKey *) 0 ;
        char result;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 1) || (items > 1)) {
            SWIG_croak("Usage: SWKey_Error(self);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_SWKey,0) < 0) {
                SWIG_croak("Type error in argument 1 of SWKey_Error. Expected _p_SWKey");
            }
        }
        result = (char)(arg1)->Error();
        
        ST(argvi) = sv_newmortal();
        sv_setpvn((SV*)ST(argvi++), &result, 1);
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}


XS(_wrap_SWKey_setText) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        SWKey *arg1 = (SWKey *) 0 ;
        char *arg2 ;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 2) || (items > 2)) {
            SWIG_croak("Usage: SWKey_setText(self,ikey);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_SWKey,0) < 0) {
                SWIG_croak("Type error in argument 1 of SWKey_setText. Expected _p_SWKey");
            }
        }
        if (!SvOK((SV*) ST(1))) arg2 = 0;
        else arg2 = (char *) SvPV(ST(1), PL_na);
        (arg1)->setText((char const *)arg2);
        
        
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}


XS(_wrap_SWKey_getText) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        SWKey *arg1 = (SWKey *) 0 ;
        char *result;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 1) || (items > 1)) {
            SWIG_croak("Usage: SWKey_getText(self);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_SWKey,0) < 0) {
                SWIG_croak("Type error in argument 1 of SWKey_getText. Expected _p_SWKey");
            }
        }
        result = (char *)((SWKey const *)arg1)->getText();
        
        ST(argvi) = sv_newmortal();
        if (result) {
            sv_setpv((SV*)ST(argvi++), (char *) result);
        }else {
            sv_setsv((SV*)ST(argvi++), &PL_sv_undef);
        }
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}


XS(_wrap_SWKey_getShortText) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        SWKey *arg1 = (SWKey *) 0 ;
        char *result;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 1) || (items > 1)) {
            SWIG_croak("Usage: SWKey_getShortText(self);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_SWKey,0) < 0) {
                SWIG_croak("Type error in argument 1 of SWKey_getShortText. Expected _p_SWKey");
            }
        }
        result = (char *)((SWKey const *)arg1)->getShortText();
        
        ST(argvi) = sv_newmortal();
        if (result) {
            sv_setpv((SV*)ST(argvi++), (char *) result);
        }else {
            sv_setsv((SV*)ST(argvi++), &PL_sv_undef);
        }
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}


XS(_wrap_SWKey_compare) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        SWKey *arg1 = (SWKey *) 0 ;
        SWKey *arg2 = 0 ;
        int result;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 2) || (items > 2)) {
            SWIG_croak("Usage: SWKey_compare(self,ikey);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_SWKey,0) < 0) {
                SWIG_croak("Type error in argument 1 of SWKey_compare. Expected _p_SWKey");
            }
        }
        {
            if (SWIG_ConvertPtr(ST(1), (void **) &arg2, SWIGTYPE_p_SWKey,0) < 0) {
                SWIG_croak("Type error in argument 2 of SWKey_compare. Expected _p_SWKey");
            }
        }
        result = (int)(arg1)->compare((SWKey const &)*arg2);
        
        ST(argvi) = sv_newmortal();
        sv_setiv(ST(argvi++), (IV) result);
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}


XS(_wrap_SWKey_equals) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        SWKey *arg1 = (SWKey *) 0 ;
        SWKey *arg2 = 0 ;
        bool result;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 2) || (items > 2)) {
            SWIG_croak("Usage: SWKey_equals(self,ikey);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_SWKey,0) < 0) {
                SWIG_croak("Type error in argument 1 of SWKey_equals. Expected _p_SWKey");
            }
        }
        {
            if (SWIG_ConvertPtr(ST(1), (void **) &arg2, SWIGTYPE_p_SWKey,0) < 0) {
                SWIG_croak("Type error in argument 2 of SWKey_equals. Expected _p_SWKey");
            }
        }
        result = (bool)(arg1)->equals((SWKey const &)*arg2);
        
        ST(argvi) = sv_newmortal();
        sv_setiv(ST(argvi++), (IV) result);
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}


XS(_wrap_SWKey_decrement) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        SWKey *arg1 = (SWKey *) 0 ;
        int arg2 = (int) 1 ;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 1) || (items > 2)) {
            SWIG_croak("Usage: SWKey_decrement(self,steps);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_SWKey,0) < 0) {
                SWIG_croak("Type error in argument 1 of SWKey_decrement. Expected _p_SWKey");
            }
        }
        if (items > 1) {
            arg2 = (int) SvIV(ST(1));
        }
        (arg1)->decrement(arg2);
        
        
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}


XS(_wrap_SWKey_increment) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        SWKey *arg1 = (SWKey *) 0 ;
        int arg2 = (int) 1 ;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 1) || (items > 2)) {
            SWIG_croak("Usage: SWKey_increment(self,steps);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_SWKey,0) < 0) {
                SWIG_croak("Type error in argument 1 of SWKey_increment. Expected _p_SWKey");
            }
        }
        if (items > 1) {
            arg2 = (int) SvIV(ST(1));
        }
        (arg1)->increment(arg2);
        
        
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}


XS(_wrap_SWKey_Traversable) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        SWKey *arg1 = (SWKey *) 0 ;
        char result;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 1) || (items > 1)) {
            SWIG_croak("Usage: SWKey_Traversable(self);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_SWKey,0) < 0) {
                SWIG_croak("Type error in argument 1 of SWKey_Traversable. Expected _p_SWKey");
            }
        }
        result = (char)(arg1)->Traversable();
        
        ST(argvi) = sv_newmortal();
        sv_setpvn((SV*)ST(argvi++), &result, 1);
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}


XS(_wrap_SWKey_Index) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        SWKey *arg1 = (SWKey *) 0 ;
        long result;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 1) || (items > 1)) {
            SWIG_croak("Usage: SWKey_Index(self);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_SWKey,0) < 0) {
                SWIG_croak("Type error in argument 1 of SWKey_Index. Expected _p_SWKey");
            }
        }
        result = (long)((SWKey const *)arg1)->Index();
        
        ST(argvi) = sv_newmortal();
        sv_setiv(ST(argvi++), (IV) result);
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}


XS(_wrap_SWKey_next) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        SWKey *arg1 = (SWKey *) 0 ;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 1) || (items > 1)) {
            SWIG_croak("Usage: SWKey_next(self);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_SWKey,0) < 0) {
                SWIG_croak("Type error in argument 1 of SWKey_next. Expected _p_SWKey");
            }
        }
        SWKey_next(arg1);
        
        
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}


XS(_wrap_SWKey_prev) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        SWKey *arg1 = (SWKey *) 0 ;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 1) || (items > 1)) {
            SWIG_croak("Usage: SWKey_prev(self);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_SWKey,0) < 0) {
                SWIG_croak("Type error in argument 1 of SWKey_prev. Expected _p_SWKey");
            }
        }
        SWKey_prev(arg1);
        
        
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}


XS(_wrap_SWKey_setKey) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        SWKey *arg1 = (SWKey *) 0 ;
        SWKey *arg2 = (SWKey *) 0 ;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 2) || (items > 2)) {
            SWIG_croak("Usage: SWKey_setKey(self,key);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_SWKey,0) < 0) {
                SWIG_croak("Type error in argument 1 of SWKey_setKey. Expected _p_SWKey");
            }
        }
        {
            if (SWIG_ConvertPtr(ST(1), (void **) &arg2, SWIGTYPE_p_SWKey,0) < 0) {
                SWIG_croak("Type error in argument 2 of SWKey_setKey. Expected _p_SWKey");
            }
        }
        SWKey_setKey(arg1,(SWKey const *)arg2);
        
        
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}


XS(_wrap_SWKey_toVerseKey) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        SWKey *arg1 = (SWKey *) 0 ;
        VerseKey *result;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 1) || (items > 1)) {
            SWIG_croak("Usage: SWKey_toVerseKey(self);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_SWKey,0) < 0) {
                SWIG_croak("Type error in argument 1 of SWKey_toVerseKey. Expected _p_SWKey");
            }
        }
        result = (VerseKey *)SWKey_toVerseKey(arg1);
        
        ST(argvi) = sv_newmortal();
        SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_VerseKey,0);
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}


XS(_wrap_new_VerseKey__SWIG_0) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        char *arg1 = (char *) 0 ;
        VerseKey *result;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 0) || (items > 1)) {
            SWIG_croak("Usage: new_VerseKey(ikey);");
        }
        if (items > 0) {
            if (!SvOK((SV*) ST(0))) arg1 = 0;
            else arg1 = (char *) SvPV(ST(0), PL_na);
        }
        result = (VerseKey *)new VerseKey((char const *)arg1);
        
        ST(argvi) = sv_newmortal();
        SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_VerseKey,0);
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}


XS(_wrap_new_VerseKey__SWIG_1) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        SWKey *arg1 = (SWKey *) 0 ;
        VerseKey *result;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 1) || (items > 1)) {
            SWIG_croak("Usage: new_VerseKey(ikey);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_SWKey,0) < 0) {
                SWIG_croak("Type error in argument 1 of new_VerseKey. Expected _p_SWKey");
            }
        }
        result = (VerseKey *)new VerseKey((SWKey const *)arg1);
        
        ST(argvi) = sv_newmortal();
        SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_VerseKey,0);
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}


XS(_wrap_new_VerseKey__SWIG_2) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        char *arg1 ;
        char *arg2 ;
        VerseKey *result;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 2) || (items > 2)) {
            SWIG_croak("Usage: new_VerseKey(min,max);");
        }
        if (!SvOK((SV*) ST(0))) arg1 = 0;
        else arg1 = (char *) SvPV(ST(0), PL_na);
        if (!SvOK((SV*) ST(1))) arg2 = 0;
        else arg2 = (char *) SvPV(ST(1), PL_na);
        result = (VerseKey *)new VerseKey((char const *)arg1,(char const *)arg2);
        
        ST(argvi) = sv_newmortal();
        SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_VerseKey,0);
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}


XS(_wrap_new_VerseKey__SWIG_3) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        VerseKey *arg1 = 0 ;
        VerseKey *result;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 1) || (items > 1)) {
            SWIG_croak("Usage: new_VerseKey(k);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_VerseKey,0) < 0) {
                SWIG_croak("Type error in argument 1 of new_VerseKey. Expected _p_VerseKey");
            }
        }
        result = (VerseKey *)new VerseKey((VerseKey const &)*arg1);
        
        ST(argvi) = sv_newmortal();
        SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_VerseKey,0);
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}


XS(_wrap_new_VerseKey) {
    dXSARGS;
    
    if ((items >= 0) && (items <= 1)) {
        int _v;
        if (items <= 0) {
            (*PL_markstack_ptr++);SWIG_CALLXS(_wrap_new_VerseKey__SWIG_0); return;
        }
        {
            _v = SvPOK(ST(0)) ? 1 : 0;
        }
        if (_v) {
            (*PL_markstack_ptr++);SWIG_CALLXS(_wrap_new_VerseKey__SWIG_0); return;
        }
    }
    if (items == 1) {
        int _v;
        {
            void *tmp;
            if (SWIG_ConvertPtr(ST(0), (void **) &tmp, SWIGTYPE_p_VerseKey, 0) == -1) {
                _v = 0;
            }else {
                _v = 1;
            }
        }
        if (_v) {
            (*PL_markstack_ptr++);SWIG_CALLXS(_wrap_new_VerseKey__SWIG_3); return;
        }
    }
    if (items == 1) {
        int _v;
        {
            void *tmp;
            if (SWIG_ConvertPtr(ST(0), (void **) &tmp, SWIGTYPE_p_SWKey, 0) == -1) {
                _v = 0;
            }else {
                _v = 1;
            }
        }
        if (_v) {
            (*PL_markstack_ptr++);SWIG_CALLXS(_wrap_new_VerseKey__SWIG_1); return;
        }
    }
    if (items == 2) {
        int _v;
        {
            _v = SvPOK(ST(0)) ? 1 : 0;
        }
        if (_v) {
            {
                _v = SvPOK(ST(1)) ? 1 : 0;
            }
            if (_v) {
                (*PL_markstack_ptr++);SWIG_CALLXS(_wrap_new_VerseKey__SWIG_2); return;
            }
        }
    }
    
    croak("No matching function for overloaded 'new_VerseKey'");
    XSRETURN(0);
}


XS(_wrap_delete_VerseKey) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        VerseKey *arg1 = (VerseKey *) 0 ;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 1) || (items > 1)) {
            SWIG_croak("Usage: delete_VerseKey(self);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_VerseKey,0) < 0) {
                SWIG_croak("Type error in argument 1 of delete_VerseKey. Expected _p_VerseKey");
            }
        }
        delete arg1;
        
        
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}


XS(_wrap_VerseKey_clone) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        VerseKey *arg1 = (VerseKey *) 0 ;
        SWKey *result;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 1) || (items > 1)) {
            SWIG_croak("Usage: VerseKey_clone(self);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_VerseKey,0) < 0) {
                SWIG_croak("Type error in argument 1 of VerseKey_clone. Expected _p_VerseKey");
            }
        }
        result = (SWKey *)((VerseKey const *)arg1)->clone();
        
        ST(argvi) = sv_newmortal();
        SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_SWKey,0);
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}


XS(_wrap_VerseKey_LowerBound) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        VerseKey *arg1 = (VerseKey *) 0 ;
        VerseKey *result;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 1) || (items > 1)) {
            SWIG_croak("Usage: VerseKey_LowerBound(self);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_VerseKey,0) < 0) {
                SWIG_croak("Type error in argument 1 of VerseKey_LowerBound. Expected _p_VerseKey");
            }
        }
        {
            VerseKey &_result_ref = ((VerseKey const *)arg1)->LowerBound();
            result = (VerseKey *) &_result_ref;
        }
        
        ST(argvi) = sv_newmortal();
        SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_VerseKey,0);
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}


XS(_wrap_VerseKey_UpperBound) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        VerseKey *arg1 = (VerseKey *) 0 ;
        VerseKey *result;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 1) || (items > 1)) {
            SWIG_croak("Usage: VerseKey_UpperBound(self);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_VerseKey,0) < 0) {
                SWIG_croak("Type error in argument 1 of VerseKey_UpperBound. Expected _p_VerseKey");
            }
        }
        {
            VerseKey &_result_ref = ((VerseKey const *)arg1)->UpperBound();
            result = (VerseKey *) &_result_ref;
        }
        
        ST(argvi) = sv_newmortal();
        SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_VerseKey,0);
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}


XS(_wrap_VerseKey_ClearBounds) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        VerseKey *arg1 = (VerseKey *) 0 ;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 1) || (items > 1)) {
            SWIG_croak("Usage: VerseKey_ClearBounds(self);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_VerseKey,0) < 0) {
                SWIG_croak("Type error in argument 1 of VerseKey_ClearBounds. Expected _p_VerseKey");
            }
        }
        (arg1)->ClearBounds();
        
        
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}


XS(_wrap_VerseKey_ParseVerseList) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        VerseKey *arg1 = (VerseKey *) 0 ;
        char *arg2 ;
        char *arg3 = (char *) "Genesis 1:1" ;
        bool arg4 = (bool) false ;
        ListKey result;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 2) || (items > 4)) {
            SWIG_croak("Usage: VerseKey_ParseVerseList(self,buf,defaultKey,expandRange);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_VerseKey,0) < 0) {
                SWIG_croak("Type error in argument 1 of VerseKey_ParseVerseList. Expected _p_VerseKey");
            }
        }
        if (!SvOK((SV*) ST(1))) arg2 = 0;
        else arg2 = (char *) SvPV(ST(1), PL_na);
        if (items > 2) {
            if (!SvOK((SV*) ST(2))) arg3 = 0;
            else arg3 = (char *) SvPV(ST(2), PL_na);
        }
        if (items > 3) {
            arg4 = (bool) SvIV(ST(3));
        }
        result = (arg1)->ParseVerseList((char const *)arg2,(char const *)arg3,arg4);
        
        {
            ListKey * resultobj = new ListKey((ListKey &)result);
            ST(argvi) = sv_newmortal();
            SWIG_MakePtr(ST(argvi++), (void *) resultobj, SWIGTYPE_p_ListKey,0);
        }
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}


XS(_wrap_VerseKey_setText) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        VerseKey *arg1 = (VerseKey *) 0 ;
        char *arg2 ;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 2) || (items > 2)) {
            SWIG_croak("Usage: VerseKey_setText(self,ikey);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_VerseKey,0) < 0) {
                SWIG_croak("Type error in argument 1 of VerseKey_setText. Expected _p_VerseKey");
            }
        }
        if (!SvOK((SV*) ST(1))) arg2 = 0;
        else arg2 = (char *) SvPV(ST(1), PL_na);
        (arg1)->setText((char const *)arg2);
        
        
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}


XS(_wrap_VerseKey_getText) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        VerseKey *arg1 = (VerseKey *) 0 ;
        char *result;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 1) || (items > 1)) {
            SWIG_croak("Usage: VerseKey_getText(self);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_VerseKey,0) < 0) {
                SWIG_croak("Type error in argument 1 of VerseKey_getText. Expected _p_VerseKey");
            }
        }
        result = (char *)((VerseKey const *)arg1)->getText();
        
        ST(argvi) = sv_newmortal();
        if (result) {
            sv_setpv((SV*)ST(argvi++), (char *) result);
        }else {
            sv_setsv((SV*)ST(argvi++), &PL_sv_undef);
        }
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}


XS(_wrap_VerseKey_getRangeText) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        VerseKey *arg1 = (VerseKey *) 0 ;
        char *result;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 1) || (items > 1)) {
            SWIG_croak("Usage: VerseKey_getRangeText(self);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_VerseKey,0) < 0) {
                SWIG_croak("Type error in argument 1 of VerseKey_getRangeText. Expected _p_VerseKey");
            }
        }
        result = (char *)((VerseKey const *)arg1)->getRangeText();
        
        ST(argvi) = sv_newmortal();
        if (result) {
            sv_setpv((SV*)ST(argvi++), (char *) result);
        }else {
            sv_setsv((SV*)ST(argvi++), &PL_sv_undef);
        }
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}


XS(_wrap_VerseKey_getShortText) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        VerseKey *arg1 = (VerseKey *) 0 ;
        char *result;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 1) || (items > 1)) {
            SWIG_croak("Usage: VerseKey_getShortText(self);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_VerseKey,0) < 0) {
                SWIG_croak("Type error in argument 1 of VerseKey_getShortText. Expected _p_VerseKey");
            }
        }
        result = (char *)((VerseKey const *)arg1)->getShortText();
        
        ST(argvi) = sv_newmortal();
        if (result) {
            sv_setpv((SV*)ST(argvi++), (char *) result);
        }else {
            sv_setsv((SV*)ST(argvi++), &PL_sv_undef);
        }
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}


XS(_wrap_VerseKey_Traversable) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        VerseKey *arg1 = (VerseKey *) 0 ;
        char result;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 1) || (items > 1)) {
            SWIG_croak("Usage: VerseKey_Traversable(self);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_VerseKey,0) < 0) {
                SWIG_croak("Type error in argument 1 of VerseKey_Traversable. Expected _p_VerseKey");
            }
        }
        result = (char)(arg1)->Traversable();
        
        ST(argvi) = sv_newmortal();
        sv_setpvn((SV*)ST(argvi++), &result, 1);
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}


XS(_wrap_VerseKey_decrement) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        VerseKey *arg1 = (VerseKey *) 0 ;
        int arg2 ;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 2) || (items > 2)) {
            SWIG_croak("Usage: VerseKey_decrement(self,step);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_VerseKey,0) < 0) {
                SWIG_croak("Type error in argument 1 of VerseKey_decrement. Expected _p_VerseKey");
            }
        }
        arg2 = (int) SvIV(ST(1));
        (arg1)->decrement(arg2);
        
        
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}


XS(_wrap_VerseKey_increment) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        VerseKey *arg1 = (VerseKey *) 0 ;
        int arg2 ;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 2) || (items > 2)) {
            SWIG_croak("Usage: VerseKey_increment(self,step);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_VerseKey,0) < 0) {
                SWIG_croak("Type error in argument 1 of VerseKey_increment. Expected _p_VerseKey");
            }
        }
        arg2 = (int) SvIV(ST(1));
        (arg1)->increment(arg2);
        
        
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}


XS(_wrap_VerseKey_getBookName) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        VerseKey *arg1 = (VerseKey *) 0 ;
        char *result;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 1) || (items > 1)) {
            SWIG_croak("Usage: VerseKey_getBookName(self);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_VerseKey,0) < 0) {
                SWIG_croak("Type error in argument 1 of VerseKey_getBookName. Expected _p_VerseKey");
            }
        }
        result = (char *)((VerseKey const *)arg1)->getBookName();
        
        ST(argvi) = sv_newmortal();
        if (result) {
            sv_setpv((SV*)ST(argvi++), (char *) result);
        }else {
            sv_setsv((SV*)ST(argvi++), &PL_sv_undef);
        }
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}


XS(_wrap_VerseKey_getBookAbbrev) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        VerseKey *arg1 = (VerseKey *) 0 ;
        char *result;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 1) || (items > 1)) {
            SWIG_croak("Usage: VerseKey_getBookAbbrev(self);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_VerseKey,0) < 0) {
                SWIG_croak("Type error in argument 1 of VerseKey_getBookAbbrev. Expected _p_VerseKey");
            }
        }
        result = (char *)((VerseKey const *)arg1)->getBookAbbrev();
        
        ST(argvi) = sv_newmortal();
        if (result) {
            sv_setpv((SV*)ST(argvi++), (char *) result);
        }else {
            sv_setsv((SV*)ST(argvi++), &PL_sv_undef);
        }
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}


XS(_wrap_VerseKey_Testament) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        VerseKey *arg1 = (VerseKey *) 0 ;
        char result;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 1) || (items > 1)) {
            SWIG_croak("Usage: VerseKey_Testament(self);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_VerseKey,0) < 0) {
                SWIG_croak("Type error in argument 1 of VerseKey_Testament. Expected _p_VerseKey");
            }
        }
        result = (char)((VerseKey const *)arg1)->Testament();
        
        ST(argvi) = sv_newmortal();
        sv_setpvn((SV*)ST(argvi++), &result, 1);
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}


XS(_wrap_VerseKey_Book) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        VerseKey *arg1 = (VerseKey *) 0 ;
        char result;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 1) || (items > 1)) {
            SWIG_croak("Usage: VerseKey_Book(self);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_VerseKey,0) < 0) {
                SWIG_croak("Type error in argument 1 of VerseKey_Book. Expected _p_VerseKey");
            }
        }
        result = (char)((VerseKey const *)arg1)->Book();
        
        ST(argvi) = sv_newmortal();
        sv_setpvn((SV*)ST(argvi++), &result, 1);
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}


XS(_wrap_VerseKey_Chapter) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        VerseKey *arg1 = (VerseKey *) 0 ;
        int result;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 1) || (items > 1)) {
            SWIG_croak("Usage: VerseKey_Chapter(self);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_VerseKey,0) < 0) {
                SWIG_croak("Type error in argument 1 of VerseKey_Chapter. Expected _p_VerseKey");
            }
        }
        result = (int)((VerseKey const *)arg1)->Chapter();
        
        ST(argvi) = sv_newmortal();
        sv_setiv(ST(argvi++), (IV) result);
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}


XS(_wrap_VerseKey_Verse) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        VerseKey *arg1 = (VerseKey *) 0 ;
        int result;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 1) || (items > 1)) {
            SWIG_croak("Usage: VerseKey_Verse(self);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_VerseKey,0) < 0) {
                SWIG_croak("Type error in argument 1 of VerseKey_Verse. Expected _p_VerseKey");
            }
        }
        result = (int)((VerseKey const *)arg1)->Verse();
        
        ST(argvi) = sv_newmortal();
        sv_setiv(ST(argvi++), (IV) result);
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}


XS(_wrap_VerseKey_Normalize) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        VerseKey *arg1 = (VerseKey *) 0 ;
        char arg2 = (char) 0 ;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 1) || (items > 2)) {
            SWIG_croak("Usage: VerseKey_Normalize(self,autocheck);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_VerseKey,0) < 0) {
                SWIG_croak("Type error in argument 1 of VerseKey_Normalize. Expected _p_VerseKey");
            }
        }
        if (items > 1) {
            arg2 = (char) *SvPV(ST(1),PL_na);
        }
        (arg1)->Normalize(arg2);
        
        
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}


XS(_wrap_VerseKey_AutoNormalize) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        VerseKey *arg1 = (VerseKey *) 0 ;
        char arg2 = (char) MAXPOS(char) ;
        char result;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 1) || (items > 2)) {
            SWIG_croak("Usage: VerseKey_AutoNormalize(self,iautonorm);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_VerseKey,0) < 0) {
                SWIG_croak("Type error in argument 1 of VerseKey_AutoNormalize. Expected _p_VerseKey");
            }
        }
        if (items > 1) {
            arg2 = (char) *SvPV(ST(1),PL_na);
        }
        result = (char)(arg1)->AutoNormalize(arg2);
        
        ST(argvi) = sv_newmortal();
        sv_setpvn((SV*)ST(argvi++), &result, 1);
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}


XS(_wrap_VerseKey_Headings) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        VerseKey *arg1 = (VerseKey *) 0 ;
        char arg2 = (char) MAXPOS(char) ;
        char result;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 1) || (items > 2)) {
            SWIG_croak("Usage: VerseKey_Headings(self,iheadings);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_VerseKey,0) < 0) {
                SWIG_croak("Type error in argument 1 of VerseKey_Headings. Expected _p_VerseKey");
            }
        }
        if (items > 1) {
            arg2 = (char) *SvPV(ST(1),PL_na);
        }
        result = (char)(arg1)->Headings(arg2);
        
        ST(argvi) = sv_newmortal();
        sv_setpvn((SV*)ST(argvi++), &result, 1);
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}


XS(_wrap_VerseKey_getOSISRef) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        VerseKey *arg1 = (VerseKey *) 0 ;
        char *result;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 1) || (items > 1)) {
            SWIG_croak("Usage: VerseKey_getOSISRef(self);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_VerseKey,0) < 0) {
                SWIG_croak("Type error in argument 1 of VerseKey_getOSISRef. Expected _p_VerseKey");
            }
        }
        result = (char *)((VerseKey const *)arg1)->getOSISRef();
        
        ST(argvi) = sv_newmortal();
        if (result) {
            sv_setpv((SV*)ST(argvi++), (char *) result);
        }else {
            sv_setsv((SV*)ST(argvi++), &PL_sv_undef);
        }
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}


XS(_wrap_VerseKey_compare) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        VerseKey *arg1 = (VerseKey *) 0 ;
        SWKey *arg2 = 0 ;
        int result;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 2) || (items > 2)) {
            SWIG_croak("Usage: VerseKey_compare(self,ikey);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_VerseKey,0) < 0) {
                SWIG_croak("Type error in argument 1 of VerseKey_compare. Expected _p_VerseKey");
            }
        }
        {
            if (SWIG_ConvertPtr(ST(1), (void **) &arg2, SWIGTYPE_p_SWKey,0) < 0) {
                SWIG_croak("Type error in argument 2 of VerseKey_compare. Expected _p_SWKey");
            }
        }
        result = (int)(arg1)->compare((SWKey const &)*arg2);
        
        ST(argvi) = sv_newmortal();
        sv_setiv(ST(argvi++), (IV) result);
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}


XS(_wrap_VerseKey__compare) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        VerseKey *arg1 = (VerseKey *) 0 ;
        VerseKey *arg2 = 0 ;
        int result;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 2) || (items > 2)) {
            SWIG_croak("Usage: VerseKey__compare(self,ikey);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_VerseKey,0) < 0) {
                SWIG_croak("Type error in argument 1 of VerseKey__compare. Expected _p_VerseKey");
            }
        }
        {
            if (SWIG_ConvertPtr(ST(1), (void **) &arg2, SWIGTYPE_p_VerseKey,0) < 0) {
                SWIG_croak("Type error in argument 2 of VerseKey__compare. Expected _p_VerseKey");
            }
        }
        result = (int)(arg1)->_compare((VerseKey const &)*arg2);
        
        ST(argvi) = sv_newmortal();
        sv_setiv(ST(argvi++), (IV) result);
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}


XS(_wrap_VerseKey_setLocale) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        VerseKey *arg1 = (VerseKey *) 0 ;
        char *arg2 ;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 2) || (items > 2)) {
            SWIG_croak("Usage: VerseKey_setLocale(self,name);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_VerseKey,0) < 0) {
                SWIG_croak("Type error in argument 1 of VerseKey_setLocale. Expected _p_VerseKey");
            }
        }
        if (!SvOK((SV*) ST(1))) arg2 = 0;
        else arg2 = (char *) SvPV(ST(1), PL_na);
        (arg1)->setLocale((char const *)arg2);
        
        
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}


XS(_wrap_VerseKey_getLocale) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        VerseKey *arg1 = (VerseKey *) 0 ;
        char *result;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 1) || (items > 1)) {
            SWIG_croak("Usage: VerseKey_getLocale(self);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_VerseKey,0) < 0) {
                SWIG_croak("Type error in argument 1 of VerseKey_getLocale. Expected _p_VerseKey");
            }
        }
        result = (char *)((VerseKey const *)arg1)->getLocale();
        
        ST(argvi) = sv_newmortal();
        if (result) {
            sv_setpv((SV*)ST(argvi++), (char *) result);
        }else {
            sv_setsv((SV*)ST(argvi++), &PL_sv_undef);
        }
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}


XS(_wrap_VerseKey_bookCount) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        VerseKey *arg1 = (VerseKey *) 0 ;
        int arg2 ;
        int result;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 2) || (items > 2)) {
            SWIG_croak("Usage: VerseKey_bookCount(self,testament);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_VerseKey,0) < 0) {
                SWIG_croak("Type error in argument 1 of VerseKey_bookCount. Expected _p_VerseKey");
            }
        }
        arg2 = (int) SvIV(ST(1));
        result = (int)VerseKey_bookCount(arg1,arg2);
        
        ST(argvi) = sv_newmortal();
        sv_setiv(ST(argvi++), (IV) result);
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}


XS(_wrap_VerseKey_bookName) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        VerseKey *arg1 = (VerseKey *) 0 ;
        int arg2 ;
        int arg3 ;
        char *result;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 3) || (items > 3)) {
            SWIG_croak("Usage: VerseKey_bookName(self,testament,book);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_VerseKey,0) < 0) {
                SWIG_croak("Type error in argument 1 of VerseKey_bookName. Expected _p_VerseKey");
            }
        }
        arg2 = (int) SvIV(ST(1));
        arg3 = (int) SvIV(ST(2));
        result = (char *)VerseKey_bookName(arg1,arg2,arg3);
        
        ST(argvi) = sv_newmortal();
        if (result) {
            sv_setpv((SV*)ST(argvi++), (char *) result);
        }else {
            sv_setsv((SV*)ST(argvi++), &PL_sv_undef);
        }
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}


XS(_wrap_VerseKey_chapterCount) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        VerseKey *arg1 = (VerseKey *) 0 ;
        int arg2 ;
        int arg3 ;
        int result;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 3) || (items > 3)) {
            SWIG_croak("Usage: VerseKey_chapterCount(self,testament,book);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_VerseKey,0) < 0) {
                SWIG_croak("Type error in argument 1 of VerseKey_chapterCount. Expected _p_VerseKey");
            }
        }
        arg2 = (int) SvIV(ST(1));
        arg3 = (int) SvIV(ST(2));
        result = (int)VerseKey_chapterCount(arg1,arg2,arg3);
        
        ST(argvi) = sv_newmortal();
        sv_setiv(ST(argvi++), (IV) result);
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}


XS(_wrap_VerseKey_verseCount) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        VerseKey *arg1 = (VerseKey *) 0 ;
        int arg2 ;
        int arg3 ;
        int arg4 ;
        int result;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 4) || (items > 4)) {
            SWIG_croak("Usage: VerseKey_verseCount(self,testament,book,chapter);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_VerseKey,0) < 0) {
                SWIG_croak("Type error in argument 1 of VerseKey_verseCount. Expected _p_VerseKey");
            }
        }
        arg2 = (int) SvIV(ST(1));
        arg3 = (int) SvIV(ST(2));
        arg4 = (int) SvIV(ST(3));
        result = (int)VerseKey_verseCount(arg1,arg2,arg3,arg4);
        
        ST(argvi) = sv_newmortal();
        sv_setiv(ST(argvi++), (IV) result);
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}


XS(_wrap_new_ListKey__SWIG_0) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        char *arg1 = (char *) 0 ;
        ListKey *result;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 0) || (items > 1)) {
            SWIG_croak("Usage: new_ListKey(ikey);");
        }
        if (items > 0) {
            if (!SvOK((SV*) ST(0))) arg1 = 0;
            else arg1 = (char *) SvPV(ST(0), PL_na);
        }
        result = (ListKey *)new ListKey((char const *)arg1);
        
        ST(argvi) = sv_newmortal();
        SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_ListKey,0);
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}


XS(_wrap_new_ListKey__SWIG_1) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        ListKey *arg1 = 0 ;
        ListKey *result;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 1) || (items > 1)) {
            SWIG_croak("Usage: new_ListKey(k);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_ListKey,0) < 0) {
                SWIG_croak("Type error in argument 1 of new_ListKey. Expected _p_ListKey");
            }
        }
        result = (ListKey *)new ListKey((ListKey const &)*arg1);
        
        ST(argvi) = sv_newmortal();
        SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_ListKey,0);
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}


XS(_wrap_new_ListKey) {
    dXSARGS;
    
    if ((items >= 0) && (items <= 1)) {
        int _v;
        if (items <= 0) {
            (*PL_markstack_ptr++);SWIG_CALLXS(_wrap_new_ListKey__SWIG_0); return;
        }
        {
            _v = SvPOK(ST(0)) ? 1 : 0;
        }
        if (_v) {
            (*PL_markstack_ptr++);SWIG_CALLXS(_wrap_new_ListKey__SWIG_0); return;
        }
    }
    if (items == 1) {
        int _v;
        {
            void *tmp;
            if (SWIG_ConvertPtr(ST(0), (void **) &tmp, SWIGTYPE_p_ListKey, 0) == -1) {
                _v = 0;
            }else {
                _v = 1;
            }
        }
        if (_v) {
            (*PL_markstack_ptr++);SWIG_CALLXS(_wrap_new_ListKey__SWIG_1); return;
        }
    }
    
    croak("No matching function for overloaded 'new_ListKey'");
    XSRETURN(0);
}


XS(_wrap_delete_ListKey) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        ListKey *arg1 = (ListKey *) 0 ;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 1) || (items > 1)) {
            SWIG_croak("Usage: delete_ListKey(self);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_ListKey,0) < 0) {
                SWIG_croak("Type error in argument 1 of delete_ListKey. Expected _p_ListKey");
            }
        }
        delete arg1;
        
        
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}


XS(_wrap_ListKey_clone) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        ListKey *arg1 = (ListKey *) 0 ;
        SWKey *result;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 1) || (items > 1)) {
            SWIG_croak("Usage: ListKey_clone(self);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_ListKey,0) < 0) {
                SWIG_croak("Type error in argument 1 of ListKey_clone. Expected _p_ListKey");
            }
        }
        result = (SWKey *)((ListKey const *)arg1)->clone();
        
        ST(argvi) = sv_newmortal();
        SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_SWKey,0);
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}


XS(_wrap_ListKey_ClearList) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        ListKey *arg1 = (ListKey *) 0 ;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 1) || (items > 1)) {
            SWIG_croak("Usage: ListKey_ClearList(self);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_ListKey,0) < 0) {
                SWIG_croak("Type error in argument 1 of ListKey_ClearList. Expected _p_ListKey");
            }
        }
        (arg1)->ClearList();
        
        
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}


XS(_wrap_ListKey_Count) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        ListKey *arg1 = (ListKey *) 0 ;
        int result;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 1) || (items > 1)) {
            SWIG_croak("Usage: ListKey_Count(self);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_ListKey,0) < 0) {
                SWIG_croak("Type error in argument 1 of ListKey_Count. Expected _p_ListKey");
            }
        }
        result = (int)(arg1)->Count();
        
        ST(argvi) = sv_newmortal();
        sv_setiv(ST(argvi++), (IV) result);
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}


XS(_wrap_ListKey_Remove) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        ListKey *arg1 = (ListKey *) 0 ;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 1) || (items > 1)) {
            SWIG_croak("Usage: ListKey_Remove(self);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_ListKey,0) < 0) {
                SWIG_croak("Type error in argument 1 of ListKey_Remove. Expected _p_ListKey");
            }
        }
        (arg1)->Remove();
        
        
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}


XS(_wrap_ListKey_SetToElement) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        ListKey *arg1 = (ListKey *) 0 ;
        int arg2 ;
        char result;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 2) || (items > 2)) {
            SWIG_croak("Usage: ListKey_SetToElement(self,element);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_ListKey,0) < 0) {
                SWIG_croak("Type error in argument 1 of ListKey_SetToElement. Expected _p_ListKey");
            }
        }
        arg2 = (int) SvIV(ST(1));
        result = (char)ListKey_SetToElement(arg1,arg2);
        
        ST(argvi) = sv_newmortal();
        sv_setpvn((SV*)ST(argvi++), &result, 1);
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}


XS(_wrap_ListKey_GetElement) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        ListKey *arg1 = (ListKey *) 0 ;
        int arg2 = (int) -1 ;
        SWKey *result;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 1) || (items > 2)) {
            SWIG_croak("Usage: ListKey_GetElement(self,pos);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_ListKey,0) < 0) {
                SWIG_croak("Type error in argument 1 of ListKey_GetElement. Expected _p_ListKey");
            }
        }
        if (items > 1) {
            arg2 = (int) SvIV(ST(1));
        }
        result = (SWKey *)(arg1)->GetElement(arg2);
        
        ST(argvi) = sv_newmortal();
        SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_SWKey,0);
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}


XS(_wrap_ListKey_add) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        ListKey *arg1 = (ListKey *) 0 ;
        SWKey *arg2 = 0 ;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 2) || (items > 2)) {
            SWIG_croak("Usage: ListKey_add(self,ikey);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_ListKey,0) < 0) {
                SWIG_croak("Type error in argument 1 of ListKey_add. Expected _p_ListKey");
            }
        }
        {
            if (SWIG_ConvertPtr(ST(1), (void **) &arg2, SWIGTYPE_p_SWKey,0) < 0) {
                SWIG_croak("Type error in argument 2 of ListKey_add. Expected _p_SWKey");
            }
        }
        (arg1)->add((SWKey const &)*arg2);
        
        
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}


XS(_wrap_ListKey_copyFrom) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        ListKey *arg1 = (ListKey *) 0 ;
        ListKey *arg2 = 0 ;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 2) || (items > 2)) {
            SWIG_croak("Usage: ListKey_copyFrom(self,ikey);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_ListKey,0) < 0) {
                SWIG_croak("Type error in argument 1 of ListKey_copyFrom. Expected _p_ListKey");
            }
        }
        {
            if (SWIG_ConvertPtr(ST(1), (void **) &arg2, SWIGTYPE_p_ListKey,0) < 0) {
                SWIG_croak("Type error in argument 2 of ListKey_copyFrom. Expected _p_ListKey");
            }
        }
        (arg1)->copyFrom((ListKey const &)*arg2);
        
        
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}


XS(_wrap_ListKey_setPosition) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        ListKey *arg1 = (ListKey *) 0 ;
        SwigValueWrapper< SW_POSITION > arg2 ;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 2) || (items > 2)) {
            SWIG_croak("Usage: ListKey_setPosition(self,SW_POSITION);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_ListKey,0) < 0) {
                SWIG_croak("Type error in argument 1 of ListKey_setPosition. Expected _p_ListKey");
            }
        }
        {
            SW_POSITION * argp;
            if (SWIG_ConvertPtr(ST(1),(void **) &argp, SWIGTYPE_p_SW_POSITION,0) < 0) {
                SWIG_croak("Type error in argument 2 of ListKey_setPosition. Expected _p_SW_POSITION");
            }
            arg2 = *argp;
        }
        (arg1)->setPosition(arg2);
        
        
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}


XS(_wrap_ListKey_decrement) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        ListKey *arg1 = (ListKey *) 0 ;
        int arg2 ;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 2) || (items > 2)) {
            SWIG_croak("Usage: ListKey_decrement(self,step);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_ListKey,0) < 0) {
                SWIG_croak("Type error in argument 1 of ListKey_decrement. Expected _p_ListKey");
            }
        }
        arg2 = (int) SvIV(ST(1));
        (arg1)->decrement(arg2);
        
        
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}


XS(_wrap_ListKey_increment) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        ListKey *arg1 = (ListKey *) 0 ;
        int arg2 ;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 2) || (items > 2)) {
            SWIG_croak("Usage: ListKey_increment(self,step);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_ListKey,0) < 0) {
                SWIG_croak("Type error in argument 1 of ListKey_increment. Expected _p_ListKey");
            }
        }
        arg2 = (int) SvIV(ST(1));
        (arg1)->increment(arg2);
        
        
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}


XS(_wrap_ListKey_Traversable) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        ListKey *arg1 = (ListKey *) 0 ;
        char result;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 1) || (items > 1)) {
            SWIG_croak("Usage: ListKey_Traversable(self);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_ListKey,0) < 0) {
                SWIG_croak("Type error in argument 1 of ListKey_Traversable. Expected _p_ListKey");
            }
        }
        result = (char)(arg1)->Traversable();
        
        ST(argvi) = sv_newmortal();
        sv_setpvn((SV*)ST(argvi++), &result, 1);
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}


XS(_wrap_ListKey_Index__SWIG_0) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        ListKey *arg1 = (ListKey *) 0 ;
        long result;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 1) || (items > 1)) {
            SWIG_croak("Usage: ListKey_Index(self);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_ListKey,0) < 0) {
                SWIG_croak("Type error in argument 1 of ListKey_Index. Expected _p_ListKey");
            }
        }
        result = (long)((ListKey const *)arg1)->Index();
        
        ST(argvi) = sv_newmortal();
        sv_setiv(ST(argvi++), (IV) result);
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}


XS(_wrap_ListKey_Index__SWIG_1) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        ListKey *arg1 = (ListKey *) 0 ;
        long arg2 ;
        long result;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 2) || (items > 2)) {
            SWIG_croak("Usage: ListKey_Index(self,index);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_ListKey,0) < 0) {
                SWIG_croak("Type error in argument 1 of ListKey_Index. Expected _p_ListKey");
            }
        }
        arg2 = (long) SvIV(ST(1));
        result = (long)(arg1)->Index(arg2);
        
        ST(argvi) = sv_newmortal();
        sv_setiv(ST(argvi++), (IV) result);
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}


XS(_wrap_ListKey_Index) {
    dXSARGS;
    
    if (items == 1) {
        int _v;
        {
            void *tmp;
            if (SWIG_ConvertPtr(ST(0), (void **) &tmp, SWIGTYPE_p_ListKey, 0) == -1) {
                _v = 0;
            }else {
                _v = 1;
            }
        }
        if (_v) {
            (*PL_markstack_ptr++);SWIG_CALLXS(_wrap_ListKey_Index__SWIG_0); return;
        }
    }
    if (items == 2) {
        int _v;
        {
            void *tmp;
            if (SWIG_ConvertPtr(ST(0), (void **) &tmp, SWIGTYPE_p_ListKey, 0) == -1) {
                _v = 0;
            }else {
                _v = 1;
            }
        }
        if (_v) {
            {
                _v = SvIOK(ST(1)) ? 1 : 0;
            }
            if (_v) {
                (*PL_markstack_ptr++);SWIG_CALLXS(_wrap_ListKey_Index__SWIG_1); return;
            }
        }
    }
    
    croak("No matching function for overloaded 'ListKey_Index'");
    XSRETURN(0);
}


XS(_wrap_TreeKey_getLocalName) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        TreeKey *arg1 = (TreeKey *) 0 ;
        char *result;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 1) || (items > 1)) {
            SWIG_croak("Usage: TreeKey_getLocalName(self);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_TreeKey,0) < 0) {
                SWIG_croak("Type error in argument 1 of TreeKey_getLocalName. Expected _p_TreeKey");
            }
        }
        result = (char *)(arg1)->getLocalName();
        
        ST(argvi) = sv_newmortal();
        if (result) {
            sv_setpv((SV*)ST(argvi++), (char *) result);
        }else {
            sv_setsv((SV*)ST(argvi++), &PL_sv_undef);
        }
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}


XS(_wrap_TreeKey_setLocalName) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        TreeKey *arg1 = (TreeKey *) 0 ;
        char *arg2 ;
        char *result;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 2) || (items > 2)) {
            SWIG_croak("Usage: TreeKey_setLocalName(self,char const *);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_TreeKey,0) < 0) {
                SWIG_croak("Type error in argument 1 of TreeKey_setLocalName. Expected _p_TreeKey");
            }
        }
        if (!SvOK((SV*) ST(1))) arg2 = 0;
        else arg2 = (char *) SvPV(ST(1), PL_na);
        result = (char *)(arg1)->setLocalName((char const *)arg2);
        
        ST(argvi) = sv_newmortal();
        if (result) {
            sv_setpv((SV*)ST(argvi++), (char *) result);
        }else {
            sv_setsv((SV*)ST(argvi++), &PL_sv_undef);
        }
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}


XS(_wrap_TreeKey_getUserData) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        TreeKey *arg1 = (TreeKey *) 0 ;
        int *arg2 = (int *) 0 ;
        char *result;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 1) || (items > 2)) {
            SWIG_croak("Usage: TreeKey_getUserData(self,size);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_TreeKey,0) < 0) {
                SWIG_croak("Type error in argument 1 of TreeKey_getUserData. Expected _p_TreeKey");
            }
        }
        if (items > 1) {
            {
                if (SWIG_ConvertPtr(ST(1), (void **) &arg2, SWIGTYPE_p_int,0) < 0) {
                    SWIG_croak("Type error in argument 2 of TreeKey_getUserData. Expected _p_int");
                }
            }
        }
        result = (char *)(arg1)->getUserData(arg2);
        
        ST(argvi) = sv_newmortal();
        if (result) {
            sv_setpv((SV*)ST(argvi++), (char *) result);
        }else {
            sv_setsv((SV*)ST(argvi++), &PL_sv_undef);
        }
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}


XS(_wrap_TreeKey_setUserData) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        TreeKey *arg1 = (TreeKey *) 0 ;
        char *arg2 ;
        int arg3 = (int) 0 ;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 2) || (items > 3)) {
            SWIG_croak("Usage: TreeKey_setUserData(self,userData,size);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_TreeKey,0) < 0) {
                SWIG_croak("Type error in argument 1 of TreeKey_setUserData. Expected _p_TreeKey");
            }
        }
        if (!SvOK((SV*) ST(1))) arg2 = 0;
        else arg2 = (char *) SvPV(ST(1), PL_na);
        if (items > 2) {
            arg3 = (int) SvIV(ST(2));
        }
        (arg1)->setUserData((char const *)arg2,arg3);
        
        
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}


XS(_wrap_TreeKey_getFullName) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        TreeKey *arg1 = (TreeKey *) 0 ;
        char *result;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 1) || (items > 1)) {
            SWIG_croak("Usage: TreeKey_getFullName(self);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_TreeKey,0) < 0) {
                SWIG_croak("Type error in argument 1 of TreeKey_getFullName. Expected _p_TreeKey");
            }
        }
        result = (char *)((TreeKey const *)arg1)->getFullName();
        
        ST(argvi) = sv_newmortal();
        if (result) {
            sv_setpv((SV*)ST(argvi++), (char *) result);
        }else {
            sv_setsv((SV*)ST(argvi++), &PL_sv_undef);
        }
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}


XS(_wrap_TreeKey_root) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        TreeKey *arg1 = (TreeKey *) 0 ;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 1) || (items > 1)) {
            SWIG_croak("Usage: TreeKey_root(self);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_TreeKey,0) < 0) {
                SWIG_croak("Type error in argument 1 of TreeKey_root. Expected _p_TreeKey");
            }
        }
        (arg1)->root();
        
        
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}


XS(_wrap_TreeKey_parent) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        TreeKey *arg1 = (TreeKey *) 0 ;
        bool result;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 1) || (items > 1)) {
            SWIG_croak("Usage: TreeKey_parent(self);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_TreeKey,0) < 0) {
                SWIG_croak("Type error in argument 1 of TreeKey_parent. Expected _p_TreeKey");
            }
        }
        result = (bool)(arg1)->parent();
        
        ST(argvi) = sv_newmortal();
        sv_setiv(ST(argvi++), (IV) result);
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}


XS(_wrap_TreeKey_firstChild) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        TreeKey *arg1 = (TreeKey *) 0 ;
        bool result;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 1) || (items > 1)) {
            SWIG_croak("Usage: TreeKey_firstChild(self);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_TreeKey,0) < 0) {
                SWIG_croak("Type error in argument 1 of TreeKey_firstChild. Expected _p_TreeKey");
            }
        }
        result = (bool)(arg1)->firstChild();
        
        ST(argvi) = sv_newmortal();
        sv_setiv(ST(argvi++), (IV) result);
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}


XS(_wrap_TreeKey_nextSibling) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        TreeKey *arg1 = (TreeKey *) 0 ;
        bool result;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 1) || (items > 1)) {
            SWIG_croak("Usage: TreeKey_nextSibling(self);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_TreeKey,0) < 0) {
                SWIG_croak("Type error in argument 1 of TreeKey_nextSibling. Expected _p_TreeKey");
            }
        }
        result = (bool)(arg1)->nextSibling();
        
        ST(argvi) = sv_newmortal();
        sv_setiv(ST(argvi++), (IV) result);
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}


XS(_wrap_TreeKey_previousSibling) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        TreeKey *arg1 = (TreeKey *) 0 ;
        bool result;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 1) || (items > 1)) {
            SWIG_croak("Usage: TreeKey_previousSibling(self);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_TreeKey,0) < 0) {
                SWIG_croak("Type error in argument 1 of TreeKey_previousSibling. Expected _p_TreeKey");
            }
        }
        result = (bool)(arg1)->previousSibling();
        
        ST(argvi) = sv_newmortal();
        sv_setiv(ST(argvi++), (IV) result);
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}


XS(_wrap_TreeKey_hasChildren) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        TreeKey *arg1 = (TreeKey *) 0 ;
        bool result;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 1) || (items > 1)) {
            SWIG_croak("Usage: TreeKey_hasChildren(self);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_TreeKey,0) < 0) {
                SWIG_croak("Type error in argument 1 of TreeKey_hasChildren. Expected _p_TreeKey");
            }
        }
        result = (bool)(arg1)->hasChildren();
        
        ST(argvi) = sv_newmortal();
        sv_setiv(ST(argvi++), (IV) result);
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}


XS(_wrap_TreeKey_append) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        TreeKey *arg1 = (TreeKey *) 0 ;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 1) || (items > 1)) {
            SWIG_croak("Usage: TreeKey_append(self);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_TreeKey,0) < 0) {
                SWIG_croak("Type error in argument 1 of TreeKey_append. Expected _p_TreeKey");
            }
        }
        (arg1)->append();
        
        
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}


XS(_wrap_TreeKey_appendChild) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        TreeKey *arg1 = (TreeKey *) 0 ;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 1) || (items > 1)) {
            SWIG_croak("Usage: TreeKey_appendChild(self);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_TreeKey,0) < 0) {
                SWIG_croak("Type error in argument 1 of TreeKey_appendChild. Expected _p_TreeKey");
            }
        }
        (arg1)->appendChild();
        
        
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}


XS(_wrap_TreeKey_insertBefore) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        TreeKey *arg1 = (TreeKey *) 0 ;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 1) || (items > 1)) {
            SWIG_croak("Usage: TreeKey_insertBefore(self);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_TreeKey,0) < 0) {
                SWIG_croak("Type error in argument 1 of TreeKey_insertBefore. Expected _p_TreeKey");
            }
        }
        (arg1)->insertBefore();
        
        
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}


XS(_wrap_TreeKey_remove) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        TreeKey *arg1 = (TreeKey *) 0 ;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 1) || (items > 1)) {
            SWIG_croak("Usage: TreeKey_remove(self);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_TreeKey,0) < 0) {
                SWIG_croak("Type error in argument 1 of TreeKey_remove. Expected _p_TreeKey");
            }
        }
        (arg1)->remove();
        
        
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}


XS(_wrap_TreeKey_setOffset) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        TreeKey *arg1 = (TreeKey *) 0 ;
        unsigned long arg2 ;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 2) || (items > 2)) {
            SWIG_croak("Usage: TreeKey_setOffset(self,offset);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_TreeKey,0) < 0) {
                SWIG_croak("Type error in argument 1 of TreeKey_setOffset. Expected _p_TreeKey");
            }
        }
        arg2 = (unsigned long) SvUV(ST(1));
        (arg1)->setOffset(arg2);
        
        
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}


XS(_wrap_TreeKey_getOffset) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        TreeKey *arg1 = (TreeKey *) 0 ;
        unsigned long result;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 1) || (items > 1)) {
            SWIG_croak("Usage: TreeKey_getOffset(self);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_TreeKey,0) < 0) {
                SWIG_croak("Type error in argument 1 of TreeKey_getOffset. Expected _p_TreeKey");
            }
        }
        result = (unsigned long)((TreeKey const *)arg1)->getOffset();
        
        ST(argvi) = sv_newmortal();
        sv_setuv(ST(argvi++), (UV) result);
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}


XS(_wrap_TreeKey_setPosition) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        TreeKey *arg1 = (TreeKey *) 0 ;
        SwigValueWrapper< SW_POSITION > arg2 ;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 2) || (items > 2)) {
            SWIG_croak("Usage: TreeKey_setPosition(self,p);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_TreeKey,0) < 0) {
                SWIG_croak("Type error in argument 1 of TreeKey_setPosition. Expected _p_TreeKey");
            }
        }
        {
            SW_POSITION * argp;
            if (SWIG_ConvertPtr(ST(1),(void **) &argp, SWIGTYPE_p_SW_POSITION,0) < 0) {
                SWIG_croak("Type error in argument 2 of TreeKey_setPosition. Expected _p_SW_POSITION");
            }
            arg2 = *argp;
        }
        (arg1)->setPosition(arg2);
        
        
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}


XS(_wrap_TreeKey_Traversable) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        TreeKey *arg1 = (TreeKey *) 0 ;
        char result;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 1) || (items > 1)) {
            SWIG_croak("Usage: TreeKey_Traversable(self);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_TreeKey,0) < 0) {
                SWIG_croak("Type error in argument 1 of TreeKey_Traversable. Expected _p_TreeKey");
            }
        }
        result = (char)(arg1)->Traversable();
        
        ST(argvi) = sv_newmortal();
        sv_setpvn((SV*)ST(argvi++), &result, 1);
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}


XS(_wrap_TreeKey_Index) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        TreeKey *arg1 = (TreeKey *) 0 ;
        long result;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 1) || (items > 1)) {
            SWIG_croak("Usage: TreeKey_Index(self);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_TreeKey,0) < 0) {
                SWIG_croak("Type error in argument 1 of TreeKey_Index. Expected _p_TreeKey");
            }
        }
        result = (long)((TreeKey const *)arg1)->Index();
        
        ST(argvi) = sv_newmortal();
        sv_setiv(ST(argvi++), (IV) result);
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}


XS(_wrap_delete_TreeKeyIdx) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        TreeKeyIdx *arg1 = (TreeKeyIdx *) 0 ;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 1) || (items > 1)) {
            SWIG_croak("Usage: delete_TreeKeyIdx(self);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_TreeKeyIdx,0) < 0) {
                SWIG_croak("Type error in argument 1 of delete_TreeKeyIdx. Expected _p_TreeKeyIdx");
            }
        }
        delete arg1;
        
        
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}


XS(_wrap_TreeKeyIdx_save) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        TreeKeyIdx *arg1 = (TreeKeyIdx *) 0 ;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 1) || (items > 1)) {
            SWIG_croak("Usage: TreeKeyIdx_save(self);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_TreeKeyIdx,0) < 0) {
                SWIG_croak("Type error in argument 1 of TreeKeyIdx_save. Expected _p_TreeKeyIdx");
            }
        }
        (arg1)->save();
        
        
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}


XS(_wrap_TreeKeyIdx_copyFrom) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        TreeKeyIdx *arg1 = (TreeKeyIdx *) 0 ;
        TreeKeyIdx *arg2 = 0 ;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 2) || (items > 2)) {
            SWIG_croak("Usage: TreeKeyIdx_copyFrom(self,ikey);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_TreeKeyIdx,0) < 0) {
                SWIG_croak("Type error in argument 1 of TreeKeyIdx_copyFrom. Expected _p_TreeKeyIdx");
            }
        }
        {
            if (SWIG_ConvertPtr(ST(1), (void **) &arg2, SWIGTYPE_p_TreeKeyIdx,0) < 0) {
                SWIG_croak("Type error in argument 2 of TreeKeyIdx_copyFrom. Expected _p_TreeKeyIdx");
            }
        }
        (arg1)->copyFrom((TreeKeyIdx const &)*arg2);
        
        
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}


XS(_wrap_TreeKeyIdx__compare) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        TreeKeyIdx *arg1 = (TreeKeyIdx *) 0 ;
        TreeKeyIdx *arg2 = 0 ;
        int result;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 2) || (items > 2)) {
            SWIG_croak("Usage: TreeKeyIdx__compare(self,ikey);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_TreeKeyIdx,0) < 0) {
                SWIG_croak("Type error in argument 1 of TreeKeyIdx__compare. Expected _p_TreeKeyIdx");
            }
        }
        {
            if (SWIG_ConvertPtr(ST(1), (void **) &arg2, SWIGTYPE_p_TreeKeyIdx,0) < 0) {
                SWIG_croak("Type error in argument 2 of TreeKeyIdx__compare. Expected _p_TreeKeyIdx");
            }
        }
        result = (int)(arg1)->_compare((TreeKeyIdx const &)*arg2);
        
        ST(argvi) = sv_newmortal();
        sv_setiv(ST(argvi++), (IV) result);
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}


XS(_wrap_TreeKeyIdx_create) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        char *arg1 ;
        signed char result;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 1) || (items > 1)) {
            SWIG_croak("Usage: TreeKeyIdx_create(path);");
        }
        if (!SvOK((SV*) ST(0))) arg1 = 0;
        else arg1 = (char *) SvPV(ST(0), PL_na);
        result = (signed char)TreeKeyIdx::create((char const *)arg1);
        
        ST(argvi) = sv_newmortal();
        sv_setiv(ST(argvi++), (IV) result);
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}


XS(_wrap_new_LocaleMgr) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        char *arg1 = (char *) 0 ;
        LocaleMgr *result;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 0) || (items > 1)) {
            SWIG_croak("Usage: new_LocaleMgr(iConfigPath);");
        }
        if (items > 0) {
            if (!SvOK((SV*) ST(0))) arg1 = 0;
            else arg1 = (char *) SvPV(ST(0), PL_na);
        }
        result = (LocaleMgr *)new LocaleMgr((char const *)arg1);
        
        ST(argvi) = sv_newmortal();
        SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_LocaleMgr,0);
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}


XS(_wrap_delete_LocaleMgr) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        LocaleMgr *arg1 = (LocaleMgr *) 0 ;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 1) || (items > 1)) {
            SWIG_croak("Usage: delete_LocaleMgr(self);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_LocaleMgr,0) < 0) {
                SWIG_croak("Type error in argument 1 of delete_LocaleMgr. Expected _p_LocaleMgr");
            }
        }
        delete arg1;
        
        
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}


XS(_wrap_LocaleMgr_getLocale) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        LocaleMgr *arg1 = (LocaleMgr *) 0 ;
        char *arg2 ;
        SWLocale *result;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 2) || (items > 2)) {
            SWIG_croak("Usage: LocaleMgr_getLocale(self,name);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_LocaleMgr,0) < 0) {
                SWIG_croak("Type error in argument 1 of LocaleMgr_getLocale. Expected _p_LocaleMgr");
            }
        }
        if (!SvOK((SV*) ST(1))) arg2 = 0;
        else arg2 = (char *) SvPV(ST(1), PL_na);
        result = (SWLocale *)(arg1)->getLocale((char const *)arg2);
        
        ST(argvi) = sv_newmortal();
        SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_SWLocale,0);
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}


XS(_wrap_LocaleMgr_getAvailableLocales) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        LocaleMgr *arg1 = (LocaleMgr *) 0 ;
        std::list<SWBuf > result;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 1) || (items > 1)) {
            SWIG_croak("Usage: LocaleMgr_getAvailableLocales(self);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_LocaleMgr,0) < 0) {
                SWIG_croak("Type error in argument 1 of LocaleMgr_getAvailableLocales. Expected _p_LocaleMgr");
            }
        }
        result = (arg1)->getAvailableLocales();
        
        {
            std::list<SWBuf > * resultobj = new std::list<SWBuf >((std::list<SWBuf > &)result);
            ST(argvi) = sv_newmortal();
            SWIG_MakePtr(ST(argvi++), (void *) resultobj, SWIGTYPE_p_std__listTSWBuf_t,0);
        }
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}


XS(_wrap_LocaleMgr_getDefaultLocaleName) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        LocaleMgr *arg1 = (LocaleMgr *) 0 ;
        char *result;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 1) || (items > 1)) {
            SWIG_croak("Usage: LocaleMgr_getDefaultLocaleName(self);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_LocaleMgr,0) < 0) {
                SWIG_croak("Type error in argument 1 of LocaleMgr_getDefaultLocaleName. Expected _p_LocaleMgr");
            }
        }
        result = (char *)(arg1)->getDefaultLocaleName();
        
        ST(argvi) = sv_newmortal();
        if (result) {
            sv_setpv((SV*)ST(argvi++), (char *) result);
        }else {
            sv_setsv((SV*)ST(argvi++), &PL_sv_undef);
        }
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}


XS(_wrap_LocaleMgr_setDefaultLocaleName) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        LocaleMgr *arg1 = (LocaleMgr *) 0 ;
        char *arg2 ;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 2) || (items > 2)) {
            SWIG_croak("Usage: LocaleMgr_setDefaultLocaleName(self,name);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_LocaleMgr,0) < 0) {
                SWIG_croak("Type error in argument 1 of LocaleMgr_setDefaultLocaleName. Expected _p_LocaleMgr");
            }
        }
        if (!SvOK((SV*) ST(1))) arg2 = 0;
        else arg2 = (char *) SvPV(ST(1), PL_na);
        (arg1)->setDefaultLocaleName((char const *)arg2);
        
        
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}


XS(_wrap_LocaleMgr_getSystemLocaleMgr) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        LocaleMgr *result;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 0) || (items > 0)) {
            SWIG_croak("Usage: LocaleMgr_getSystemLocaleMgr();");
        }
        result = (LocaleMgr *)LocaleMgr_getSystemLocaleMgr();
        
        ST(argvi) = sv_newmortal();
        SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_LocaleMgr,0);
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}


XS(_wrap_new_SWText) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        char *arg1 = (char *) 0 ;
        char *arg2 = (char *) 0 ;
        SWDisplay *arg3 = (SWDisplay *) 0 ;
        SWTextEncoding arg4 = (SWTextEncoding) ENC_UNKNOWN ;
        SWTextDirection arg5 = (SWTextDirection) DIRECTION_LTR ;
        SWTextMarkup arg6 = (SWTextMarkup) FMT_UNKNOWN ;
        char *arg7 = (char *) 0 ;
        SWText *result;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 0) || (items > 7)) {
            SWIG_croak("Usage: new_SWText(imodname,imoddesc,idisp,encoding,dir,markup,ilang);");
        }
        if (items > 0) {
            if (!SvOK((SV*) ST(0))) arg1 = 0;
            else arg1 = (char *) SvPV(ST(0), PL_na);
        }
        if (items > 1) {
            if (!SvOK((SV*) ST(1))) arg2 = 0;
            else arg2 = (char *) SvPV(ST(1), PL_na);
        }
        if (items > 2) {
            {
                if (SWIG_ConvertPtr(ST(2), (void **) &arg3, SWIGTYPE_p_SWDisplay,0) < 0) {
                    SWIG_croak("Type error in argument 3 of new_SWText. Expected _p_SWDisplay");
                }
            }
        }
        if (items > 3) {
            {
                SWTextEncoding * argp;
                if (SWIG_ConvertPtr(ST(3),(void **) &argp, SWIGTYPE_p_SWTextEncoding,0) < 0) {
                    SWIG_croak("Type error in argument 4 of new_SWText. Expected _p_SWTextEncoding");
                }
                arg4 = *argp;
            }
        }
        if (items > 4) {
            {
                SWTextDirection * argp;
                if (SWIG_ConvertPtr(ST(4),(void **) &argp, SWIGTYPE_p_SWTextDirection,0) < 0) {
                    SWIG_croak("Type error in argument 5 of new_SWText. Expected _p_SWTextDirection");
                }
                arg5 = *argp;
            }
        }
        if (items > 5) {
            {
                SWTextMarkup * argp;
                if (SWIG_ConvertPtr(ST(5),(void **) &argp, SWIGTYPE_p_SWTextMarkup,0) < 0) {
                    SWIG_croak("Type error in argument 6 of new_SWText. Expected _p_SWTextMarkup");
                }
                arg6 = *argp;
            }
        }
        if (items > 6) {
            if (!SvOK((SV*) ST(6))) arg7 = 0;
            else arg7 = (char *) SvPV(ST(6), PL_na);
        }
        result = (SWText *)new SWText((char const *)arg1,(char const *)arg2,arg3,arg4,arg5,arg6,(char const *)arg7);
        
        ST(argvi) = sv_newmortal();
        SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_SWText,0);
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}


XS(_wrap_delete_SWText) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        SWText *arg1 = (SWText *) 0 ;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 1) || (items > 1)) {
            SWIG_croak("Usage: delete_SWText(self);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_SWText,0) < 0) {
                SWIG_croak("Type error in argument 1 of delete_SWText. Expected _p_SWText");
            }
        }
        delete arg1;
        
        
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}


XS(_wrap_new_RawText) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        char *arg1 ;
        char *arg2 = (char *) 0 ;
        char *arg3 = (char *) 0 ;
        SWDisplay *arg4 = (SWDisplay *) 0 ;
        SWTextEncoding arg5 = (SWTextEncoding) ENC_UNKNOWN ;
        SWTextDirection arg6 = (SWTextDirection) DIRECTION_LTR ;
        SWTextMarkup arg7 = (SWTextMarkup) FMT_UNKNOWN ;
        char *arg8 = (char *) 0 ;
        RawText *result;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 1) || (items > 8)) {
            SWIG_croak("Usage: new_RawText(ipath,iname,idesc,idisp,encoding,dir,markup,ilang);");
        }
        if (!SvOK((SV*) ST(0))) arg1 = 0;
        else arg1 = (char *) SvPV(ST(0), PL_na);
        if (items > 1) {
            if (!SvOK((SV*) ST(1))) arg2 = 0;
            else arg2 = (char *) SvPV(ST(1), PL_na);
        }
        if (items > 2) {
            if (!SvOK((SV*) ST(2))) arg3 = 0;
            else arg3 = (char *) SvPV(ST(2), PL_na);
        }
        if (items > 3) {
            {
                if (SWIG_ConvertPtr(ST(3), (void **) &arg4, SWIGTYPE_p_SWDisplay,0) < 0) {
                    SWIG_croak("Type error in argument 4 of new_RawText. Expected _p_SWDisplay");
                }
            }
        }
        if (items > 4) {
            {
                SWTextEncoding * argp;
                if (SWIG_ConvertPtr(ST(4),(void **) &argp, SWIGTYPE_p_SWTextEncoding,0) < 0) {
                    SWIG_croak("Type error in argument 5 of new_RawText. Expected _p_SWTextEncoding");
                }
                arg5 = *argp;
            }
        }
        if (items > 5) {
            {
                SWTextDirection * argp;
                if (SWIG_ConvertPtr(ST(5),(void **) &argp, SWIGTYPE_p_SWTextDirection,0) < 0) {
                    SWIG_croak("Type error in argument 6 of new_RawText. Expected _p_SWTextDirection");
                }
                arg6 = *argp;
            }
        }
        if (items > 6) {
            {
                SWTextMarkup * argp;
                if (SWIG_ConvertPtr(ST(6),(void **) &argp, SWIGTYPE_p_SWTextMarkup,0) < 0) {
                    SWIG_croak("Type error in argument 7 of new_RawText. Expected _p_SWTextMarkup");
                }
                arg7 = *argp;
            }
        }
        if (items > 7) {
            if (!SvOK((SV*) ST(7))) arg8 = 0;
            else arg8 = (char *) SvPV(ST(7), PL_na);
        }
        result = (RawText *)new RawText((char const *)arg1,(char const *)arg2,(char const *)arg3,arg4,arg5,arg6,arg7,(char const *)arg8);
        
        ST(argvi) = sv_newmortal();
        SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_RawText,0);
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}


XS(_wrap_RawText_createModule) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        char *arg1 ;
        char result;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 1) || (items > 1)) {
            SWIG_croak("Usage: RawText_createModule(path);");
        }
        if (!SvOK((SV*) ST(0))) arg1 = 0;
        else arg1 = (char *) SvPV(ST(0), PL_na);
        result = (char)RawText::createModule((char const *)arg1);
        
        ST(argvi) = sv_newmortal();
        sv_setpvn((SV*)ST(argvi++), &result, 1);
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}


XS(_wrap_delete_RawText) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        RawText *arg1 = (RawText *) 0 ;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 1) || (items > 1)) {
            SWIG_croak("Usage: delete_RawText(self);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_RawText,0) < 0) {
                SWIG_croak("Type error in argument 1 of delete_RawText. Expected _p_RawText");
            }
        }
        delete arg1;
        
        
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}


XS(_wrap_new_zText) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        char *arg1 ;
        char *arg2 = (char *) 0 ;
        char *arg3 = (char *) 0 ;
        int arg4 = (int) CHAPTERBLOCKS ;
        SWCompress *arg5 = (SWCompress *) 0 ;
        SWDisplay *arg6 = (SWDisplay *) 0 ;
        SWTextEncoding arg7 = (SWTextEncoding) ENC_UNKNOWN ;
        SWTextDirection arg8 = (SWTextDirection) DIRECTION_LTR ;
        SWTextMarkup arg9 = (SWTextMarkup) FMT_UNKNOWN ;
        char *arg10 = (char *) 0 ;
        zText *result;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 1) || (items > 10)) {
            SWIG_croak("Usage: new_zText(ipath,iname,idesc,blockType,icomp,idisp,encoding,dir,markup,ilang);");
        }
        if (!SvOK((SV*) ST(0))) arg1 = 0;
        else arg1 = (char *) SvPV(ST(0), PL_na);
        if (items > 1) {
            if (!SvOK((SV*) ST(1))) arg2 = 0;
            else arg2 = (char *) SvPV(ST(1), PL_na);
        }
        if (items > 2) {
            if (!SvOK((SV*) ST(2))) arg3 = 0;
            else arg3 = (char *) SvPV(ST(2), PL_na);
        }
        if (items > 3) {
            arg4 = (int) SvIV(ST(3));
        }
        if (items > 4) {
            {
                if (SWIG_ConvertPtr(ST(4), (void **) &arg5, SWIGTYPE_p_SWCompress,0) < 0) {
                    SWIG_croak("Type error in argument 5 of new_zText. Expected _p_SWCompress");
                }
            }
        }
        if (items > 5) {
            {
                if (SWIG_ConvertPtr(ST(5), (void **) &arg6, SWIGTYPE_p_SWDisplay,0) < 0) {
                    SWIG_croak("Type error in argument 6 of new_zText. Expected _p_SWDisplay");
                }
            }
        }
        if (items > 6) {
            {
                SWTextEncoding * argp;
                if (SWIG_ConvertPtr(ST(6),(void **) &argp, SWIGTYPE_p_SWTextEncoding,0) < 0) {
                    SWIG_croak("Type error in argument 7 of new_zText. Expected _p_SWTextEncoding");
                }
                arg7 = *argp;
            }
        }
        if (items > 7) {
            {
                SWTextDirection * argp;
                if (SWIG_ConvertPtr(ST(7),(void **) &argp, SWIGTYPE_p_SWTextDirection,0) < 0) {
                    SWIG_croak("Type error in argument 8 of new_zText. Expected _p_SWTextDirection");
                }
                arg8 = *argp;
            }
        }
        if (items > 8) {
            {
                SWTextMarkup * argp;
                if (SWIG_ConvertPtr(ST(8),(void **) &argp, SWIGTYPE_p_SWTextMarkup,0) < 0) {
                    SWIG_croak("Type error in argument 9 of new_zText. Expected _p_SWTextMarkup");
                }
                arg9 = *argp;
            }
        }
        if (items > 9) {
            if (!SvOK((SV*) ST(9))) arg10 = 0;
            else arg10 = (char *) SvPV(ST(9), PL_na);
        }
        result = (zText *)new zText((char const *)arg1,(char const *)arg2,(char const *)arg3,arg4,arg5,arg6,arg7,arg8,arg9,(char const *)arg10);
        
        ST(argvi) = sv_newmortal();
        SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_zText,0);
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}


XS(_wrap_delete_zText) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        zText *arg1 = (zText *) 0 ;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 1) || (items > 1)) {
            SWIG_croak("Usage: delete_zText(self);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_zText,0) < 0) {
                SWIG_croak("Type error in argument 1 of delete_zText. Expected _p_zText");
            }
        }
        delete arg1;
        
        
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}


XS(_wrap_zText_createModule) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        char *arg1 ;
        int arg2 ;
        char result;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 2) || (items > 2)) {
            SWIG_croak("Usage: zText_createModule(path,blockBound);");
        }
        if (!SvOK((SV*) ST(0))) arg1 = 0;
        else arg1 = (char *) SvPV(ST(0), PL_na);
        arg2 = (int) SvIV(ST(1));
        result = (char)zText::createModule((char const *)arg1,arg2);
        
        ST(argvi) = sv_newmortal();
        sv_setpvn((SV*)ST(argvi++), &result, 1);
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}


XS(_wrap_new_RawCom) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        char *arg1 ;
        char *arg2 = (char *) 0 ;
        char *arg3 = (char *) 0 ;
        SWDisplay *arg4 = (SWDisplay *) 0 ;
        SWTextEncoding arg5 = (SWTextEncoding) ENC_UNKNOWN ;
        SWTextDirection arg6 = (SWTextDirection) DIRECTION_LTR ;
        SWTextMarkup arg7 = (SWTextMarkup) FMT_UNKNOWN ;
        char *arg8 = (char *) 0 ;
        RawCom *result;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 1) || (items > 8)) {
            SWIG_croak("Usage: new_RawCom(ipath,iname,idesc,idisp,encoding,dir,markup,ilang);");
        }
        if (!SvOK((SV*) ST(0))) arg1 = 0;
        else arg1 = (char *) SvPV(ST(0), PL_na);
        if (items > 1) {
            if (!SvOK((SV*) ST(1))) arg2 = 0;
            else arg2 = (char *) SvPV(ST(1), PL_na);
        }
        if (items > 2) {
            if (!SvOK((SV*) ST(2))) arg3 = 0;
            else arg3 = (char *) SvPV(ST(2), PL_na);
        }
        if (items > 3) {
            {
                if (SWIG_ConvertPtr(ST(3), (void **) &arg4, SWIGTYPE_p_SWDisplay,0) < 0) {
                    SWIG_croak("Type error in argument 4 of new_RawCom. Expected _p_SWDisplay");
                }
            }
        }
        if (items > 4) {
            {
                SWTextEncoding * argp;
                if (SWIG_ConvertPtr(ST(4),(void **) &argp, SWIGTYPE_p_SWTextEncoding,0) < 0) {
                    SWIG_croak("Type error in argument 5 of new_RawCom. Expected _p_SWTextEncoding");
                }
                arg5 = *argp;
            }
        }
        if (items > 5) {
            {
                SWTextDirection * argp;
                if (SWIG_ConvertPtr(ST(5),(void **) &argp, SWIGTYPE_p_SWTextDirection,0) < 0) {
                    SWIG_croak("Type error in argument 6 of new_RawCom. Expected _p_SWTextDirection");
                }
                arg6 = *argp;
            }
        }
        if (items > 6) {
            {
                SWTextMarkup * argp;
                if (SWIG_ConvertPtr(ST(6),(void **) &argp, SWIGTYPE_p_SWTextMarkup,0) < 0) {
                    SWIG_croak("Type error in argument 7 of new_RawCom. Expected _p_SWTextMarkup");
                }
                arg7 = *argp;
            }
        }
        if (items > 7) {
            if (!SvOK((SV*) ST(7))) arg8 = 0;
            else arg8 = (char *) SvPV(ST(7), PL_na);
        }
        result = (RawCom *)new RawCom((char const *)arg1,(char const *)arg2,(char const *)arg3,arg4,arg5,arg6,arg7,(char const *)arg8);
        
        ST(argvi) = sv_newmortal();
        SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_RawCom,0);
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}


XS(_wrap_delete_RawCom) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        RawCom *arg1 = (RawCom *) 0 ;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 1) || (items > 1)) {
            SWIG_croak("Usage: delete_RawCom(self);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_RawCom,0) < 0) {
                SWIG_croak("Type error in argument 1 of delete_RawCom. Expected _p_RawCom");
            }
        }
        delete arg1;
        
        
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}


XS(_wrap_RawCom_createModule) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        char *arg1 ;
        char result;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 1) || (items > 1)) {
            SWIG_croak("Usage: RawCom_createModule(path);");
        }
        if (!SvOK((SV*) ST(0))) arg1 = 0;
        else arg1 = (char *) SvPV(ST(0), PL_na);
        result = (char)RawCom::createModule((char const *)arg1);
        
        ST(argvi) = sv_newmortal();
        sv_setpvn((SV*)ST(argvi++), &result, 1);
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}


XS(_wrap_new_zCom) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        char *arg1 ;
        char *arg2 = (char *) 0 ;
        char *arg3 = (char *) 0 ;
        int arg4 = (int) CHAPTERBLOCKS ;
        SWCompress *arg5 = (SWCompress *) 0 ;
        SWDisplay *arg6 = (SWDisplay *) 0 ;
        SWTextEncoding arg7 = (SWTextEncoding) ENC_UNKNOWN ;
        SWTextDirection arg8 = (SWTextDirection) DIRECTION_LTR ;
        SWTextMarkup arg9 = (SWTextMarkup) FMT_UNKNOWN ;
        char *arg10 = (char *) 0 ;
        zCom *result;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 1) || (items > 10)) {
            SWIG_croak("Usage: new_zCom(ipath,iname,idesc,blockType,icomp,idisp,encoding,dir,markup,ilang);");
        }
        if (!SvOK((SV*) ST(0))) arg1 = 0;
        else arg1 = (char *) SvPV(ST(0), PL_na);
        if (items > 1) {
            if (!SvOK((SV*) ST(1))) arg2 = 0;
            else arg2 = (char *) SvPV(ST(1), PL_na);
        }
        if (items > 2) {
            if (!SvOK((SV*) ST(2))) arg3 = 0;
            else arg3 = (char *) SvPV(ST(2), PL_na);
        }
        if (items > 3) {
            arg4 = (int) SvIV(ST(3));
        }
        if (items > 4) {
            {
                if (SWIG_ConvertPtr(ST(4), (void **) &arg5, SWIGTYPE_p_SWCompress,0) < 0) {
                    SWIG_croak("Type error in argument 5 of new_zCom. Expected _p_SWCompress");
                }
            }
        }
        if (items > 5) {
            {
                if (SWIG_ConvertPtr(ST(5), (void **) &arg6, SWIGTYPE_p_SWDisplay,0) < 0) {
                    SWIG_croak("Type error in argument 6 of new_zCom. Expected _p_SWDisplay");
                }
            }
        }
        if (items > 6) {
            {
                SWTextEncoding * argp;
                if (SWIG_ConvertPtr(ST(6),(void **) &argp, SWIGTYPE_p_SWTextEncoding,0) < 0) {
                    SWIG_croak("Type error in argument 7 of new_zCom. Expected _p_SWTextEncoding");
                }
                arg7 = *argp;
            }
        }
        if (items > 7) {
            {
                SWTextDirection * argp;
                if (SWIG_ConvertPtr(ST(7),(void **) &argp, SWIGTYPE_p_SWTextDirection,0) < 0) {
                    SWIG_croak("Type error in argument 8 of new_zCom. Expected _p_SWTextDirection");
                }
                arg8 = *argp;
            }
        }
        if (items > 8) {
            {
                SWTextMarkup * argp;
                if (SWIG_ConvertPtr(ST(8),(void **) &argp, SWIGTYPE_p_SWTextMarkup,0) < 0) {
                    SWIG_croak("Type error in argument 9 of new_zCom. Expected _p_SWTextMarkup");
                }
                arg9 = *argp;
            }
        }
        if (items > 9) {
            if (!SvOK((SV*) ST(9))) arg10 = 0;
            else arg10 = (char *) SvPV(ST(9), PL_na);
        }
        result = (zCom *)new zCom((char const *)arg1,(char const *)arg2,(char const *)arg3,arg4,arg5,arg6,arg7,arg8,arg9,(char const *)arg10);
        
        ST(argvi) = sv_newmortal();
        SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_zCom,0);
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}


XS(_wrap_delete_zCom) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        zCom *arg1 = (zCom *) 0 ;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 1) || (items > 1)) {
            SWIG_croak("Usage: delete_zCom(self);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_zCom,0) < 0) {
                SWIG_croak("Type error in argument 1 of delete_zCom. Expected _p_zCom");
            }
        }
        delete arg1;
        
        
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}


XS(_wrap_zCom_createModule) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        char *arg1 ;
        int arg2 ;
        char result;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 2) || (items > 2)) {
            SWIG_croak("Usage: zCom_createModule(path,blockBound);");
        }
        if (!SvOK((SV*) ST(0))) arg1 = 0;
        else arg1 = (char *) SvPV(ST(0), PL_na);
        arg2 = (int) SvIV(ST(1));
        result = (char)zCom::createModule((char const *)arg1,arg2);
        
        ST(argvi) = sv_newmortal();
        sv_setpvn((SV*)ST(argvi++), &result, 1);
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}


XS(_wrap_new_RawGenBook) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        char *arg1 ;
        char *arg2 = (char *) 0 ;
        char *arg3 = (char *) 0 ;
        SWDisplay *arg4 = (SWDisplay *) 0 ;
        SWTextEncoding arg5 = (SWTextEncoding) ENC_UNKNOWN ;
        SWTextDirection arg6 = (SWTextDirection) DIRECTION_LTR ;
        SWTextMarkup arg7 = (SWTextMarkup) FMT_UNKNOWN ;
        char *arg8 = (char *) 0 ;
        RawGenBook *result;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 1) || (items > 8)) {
            SWIG_croak("Usage: new_RawGenBook(ipath,iname,idesc,idisp,encoding,dir,markup,ilang);");
        }
        if (!SvOK((SV*) ST(0))) arg1 = 0;
        else arg1 = (char *) SvPV(ST(0), PL_na);
        if (items > 1) {
            if (!SvOK((SV*) ST(1))) arg2 = 0;
            else arg2 = (char *) SvPV(ST(1), PL_na);
        }
        if (items > 2) {
            if (!SvOK((SV*) ST(2))) arg3 = 0;
            else arg3 = (char *) SvPV(ST(2), PL_na);
        }
        if (items > 3) {
            {
                if (SWIG_ConvertPtr(ST(3), (void **) &arg4, SWIGTYPE_p_SWDisplay,0) < 0) {
                    SWIG_croak("Type error in argument 4 of new_RawGenBook. Expected _p_SWDisplay");
                }
            }
        }
        if (items > 4) {
            {
                SWTextEncoding * argp;
                if (SWIG_ConvertPtr(ST(4),(void **) &argp, SWIGTYPE_p_SWTextEncoding,0) < 0) {
                    SWIG_croak("Type error in argument 5 of new_RawGenBook. Expected _p_SWTextEncoding");
                }
                arg5 = *argp;
            }
        }
        if (items > 5) {
            {
                SWTextDirection * argp;
                if (SWIG_ConvertPtr(ST(5),(void **) &argp, SWIGTYPE_p_SWTextDirection,0) < 0) {
                    SWIG_croak("Type error in argument 6 of new_RawGenBook. Expected _p_SWTextDirection");
                }
                arg6 = *argp;
            }
        }
        if (items > 6) {
            {
                SWTextMarkup * argp;
                if (SWIG_ConvertPtr(ST(6),(void **) &argp, SWIGTYPE_p_SWTextMarkup,0) < 0) {
                    SWIG_croak("Type error in argument 7 of new_RawGenBook. Expected _p_SWTextMarkup");
                }
                arg7 = *argp;
            }
        }
        if (items > 7) {
            if (!SvOK((SV*) ST(7))) arg8 = 0;
            else arg8 = (char *) SvPV(ST(7), PL_na);
        }
        result = (RawGenBook *)new RawGenBook((char const *)arg1,(char const *)arg2,(char const *)arg3,arg4,arg5,arg6,arg7,(char const *)arg8);
        
        ST(argvi) = sv_newmortal();
        SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_RawGenBook,0);
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}


XS(_wrap_delete_RawGenBook) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        RawGenBook *arg1 = (RawGenBook *) 0 ;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 1) || (items > 1)) {
            SWIG_croak("Usage: delete_RawGenBook(self);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_RawGenBook,0) < 0) {
                SWIG_croak("Type error in argument 1 of delete_RawGenBook. Expected _p_RawGenBook");
            }
        }
        delete arg1;
        
        
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}


XS(_wrap_RawGenBook_createModule) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        char *arg1 ;
        char result;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 1) || (items > 1)) {
            SWIG_croak("Usage: RawGenBook_createModule(ipath);");
        }
        if (!SvOK((SV*) ST(0))) arg1 = 0;
        else arg1 = (char *) SvPV(ST(0), PL_na);
        result = (char)RawGenBook::createModule((char const *)arg1);
        
        ST(argvi) = sv_newmortal();
        sv_setpvn((SV*)ST(argvi++), &result, 1);
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}


XS(_wrap_RawGenBook_getTreeKey) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        RawGenBook *arg1 = (RawGenBook *) 0 ;
        TreeKeyIdx *result;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 1) || (items > 1)) {
            SWIG_croak("Usage: RawGenBook_getTreeKey(self);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_RawGenBook,0) < 0) {
                SWIG_croak("Type error in argument 1 of RawGenBook_getTreeKey. Expected _p_RawGenBook");
            }
        }
        result = (TreeKeyIdx *)RawGenBook_getTreeKey(arg1);
        
        ST(argvi) = sv_newmortal();
        SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_TreeKeyIdx,0);
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}


XS(_wrap_new_SWLD) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        char *arg1 = (char *) 0 ;
        char *arg2 = (char *) 0 ;
        SWDisplay *arg3 = (SWDisplay *) 0 ;
        SWTextEncoding arg4 = (SWTextEncoding) ENC_UNKNOWN ;
        SWTextDirection arg5 = (SWTextDirection) DIRECTION_LTR ;
        SWTextMarkup arg6 = (SWTextMarkup) FMT_UNKNOWN ;
        char *arg7 = (char *) 0 ;
        SWLD *result;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 0) || (items > 7)) {
            SWIG_croak("Usage: new_SWLD(imodname,imoddesc,idisp,encoding,dir,markup,ilang);");
        }
        if (items > 0) {
            if (!SvOK((SV*) ST(0))) arg1 = 0;
            else arg1 = (char *) SvPV(ST(0), PL_na);
        }
        if (items > 1) {
            if (!SvOK((SV*) ST(1))) arg2 = 0;
            else arg2 = (char *) SvPV(ST(1), PL_na);
        }
        if (items > 2) {
            {
                if (SWIG_ConvertPtr(ST(2), (void **) &arg3, SWIGTYPE_p_SWDisplay,0) < 0) {
                    SWIG_croak("Type error in argument 3 of new_SWLD. Expected _p_SWDisplay");
                }
            }
        }
        if (items > 3) {
            {
                SWTextEncoding * argp;
                if (SWIG_ConvertPtr(ST(3),(void **) &argp, SWIGTYPE_p_SWTextEncoding,0) < 0) {
                    SWIG_croak("Type error in argument 4 of new_SWLD. Expected _p_SWTextEncoding");
                }
                arg4 = *argp;
            }
        }
        if (items > 4) {
            {
                SWTextDirection * argp;
                if (SWIG_ConvertPtr(ST(4),(void **) &argp, SWIGTYPE_p_SWTextDirection,0) < 0) {
                    SWIG_croak("Type error in argument 5 of new_SWLD. Expected _p_SWTextDirection");
                }
                arg5 = *argp;
            }
        }
        if (items > 5) {
            {
                SWTextMarkup * argp;
                if (SWIG_ConvertPtr(ST(5),(void **) &argp, SWIGTYPE_p_SWTextMarkup,0) < 0) {
                    SWIG_croak("Type error in argument 6 of new_SWLD. Expected _p_SWTextMarkup");
                }
                arg6 = *argp;
            }
        }
        if (items > 6) {
            if (!SvOK((SV*) ST(6))) arg7 = 0;
            else arg7 = (char *) SvPV(ST(6), PL_na);
        }
        result = (SWLD *)new SWLD((char const *)arg1,(char const *)arg2,arg3,arg4,arg5,arg6,(char const *)arg7);
        
        ST(argvi) = sv_newmortal();
        SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_SWLD,0);
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}


XS(_wrap_delete_SWLD) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        SWLD *arg1 = (SWLD *) 0 ;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 1) || (items > 1)) {
            SWIG_croak("Usage: delete_SWLD(self);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_SWLD,0) < 0) {
                SWIG_croak("Type error in argument 1 of delete_SWLD. Expected _p_SWLD");
            }
        }
        delete arg1;
        
        
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}


XS(_wrap_new_RawLD) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        char *arg1 ;
        char *arg2 = (char *) 0 ;
        char *arg3 = (char *) 0 ;
        SWDisplay *arg4 = (SWDisplay *) 0 ;
        SWTextEncoding arg5 = (SWTextEncoding) ENC_UNKNOWN ;
        SWTextDirection arg6 = (SWTextDirection) DIRECTION_LTR ;
        SWTextMarkup arg7 = (SWTextMarkup) FMT_UNKNOWN ;
        char *arg8 = (char *) 0 ;
        RawLD *result;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 1) || (items > 8)) {
            SWIG_croak("Usage: new_RawLD(ipath,iname,idesc,idisp,encoding,dir,markup,ilang);");
        }
        if (!SvOK((SV*) ST(0))) arg1 = 0;
        else arg1 = (char *) SvPV(ST(0), PL_na);
        if (items > 1) {
            if (!SvOK((SV*) ST(1))) arg2 = 0;
            else arg2 = (char *) SvPV(ST(1), PL_na);
        }
        if (items > 2) {
            if (!SvOK((SV*) ST(2))) arg3 = 0;
            else arg3 = (char *) SvPV(ST(2), PL_na);
        }
        if (items > 3) {
            {
                if (SWIG_ConvertPtr(ST(3), (void **) &arg4, SWIGTYPE_p_SWDisplay,0) < 0) {
                    SWIG_croak("Type error in argument 4 of new_RawLD. Expected _p_SWDisplay");
                }
            }
        }
        if (items > 4) {
            {
                SWTextEncoding * argp;
                if (SWIG_ConvertPtr(ST(4),(void **) &argp, SWIGTYPE_p_SWTextEncoding,0) < 0) {
                    SWIG_croak("Type error in argument 5 of new_RawLD. Expected _p_SWTextEncoding");
                }
                arg5 = *argp;
            }
        }
        if (items > 5) {
            {
                SWTextDirection * argp;
                if (SWIG_ConvertPtr(ST(5),(void **) &argp, SWIGTYPE_p_SWTextDirection,0) < 0) {
                    SWIG_croak("Type error in argument 6 of new_RawLD. Expected _p_SWTextDirection");
                }
                arg6 = *argp;
            }
        }
        if (items > 6) {
            {
                SWTextMarkup * argp;
                if (SWIG_ConvertPtr(ST(6),(void **) &argp, SWIGTYPE_p_SWTextMarkup,0) < 0) {
                    SWIG_croak("Type error in argument 7 of new_RawLD. Expected _p_SWTextMarkup");
                }
                arg7 = *argp;
            }
        }
        if (items > 7) {
            if (!SvOK((SV*) ST(7))) arg8 = 0;
            else arg8 = (char *) SvPV(ST(7), PL_na);
        }
        result = (RawLD *)new RawLD((char const *)arg1,(char const *)arg2,(char const *)arg3,arg4,arg5,arg6,arg7,(char const *)arg8);
        
        ST(argvi) = sv_newmortal();
        SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_RawLD,0);
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}


XS(_wrap_delete_RawLD) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        RawLD *arg1 = (RawLD *) 0 ;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 1) || (items > 1)) {
            SWIG_croak("Usage: delete_RawLD(self);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_RawLD,0) < 0) {
                SWIG_croak("Type error in argument 1 of delete_RawLD. Expected _p_RawLD");
            }
        }
        delete arg1;
        
        
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}


XS(_wrap_RawLD_createModule) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        char *arg1 ;
        char result;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 1) || (items > 1)) {
            SWIG_croak("Usage: RawLD_createModule(path);");
        }
        if (!SvOK((SV*) ST(0))) arg1 = 0;
        else arg1 = (char *) SvPV(ST(0), PL_na);
        result = (char)RawLD::createModule((char const *)arg1);
        
        ST(argvi) = sv_newmortal();
        sv_setpvn((SV*)ST(argvi++), &result, 1);
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}


XS(_wrap_new_RawLD4) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        char *arg1 ;
        char *arg2 = (char *) 0 ;
        char *arg3 = (char *) 0 ;
        SWDisplay *arg4 = (SWDisplay *) 0 ;
        SWTextEncoding arg5 = (SWTextEncoding) ENC_UNKNOWN ;
        SWTextDirection arg6 = (SWTextDirection) DIRECTION_LTR ;
        SWTextMarkup arg7 = (SWTextMarkup) FMT_UNKNOWN ;
        char *arg8 = (char *) 0 ;
        RawLD4 *result;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 1) || (items > 8)) {
            SWIG_croak("Usage: new_RawLD4(ipath,iname,idesc,idisp,encoding,dir,markup,ilang);");
        }
        if (!SvOK((SV*) ST(0))) arg1 = 0;
        else arg1 = (char *) SvPV(ST(0), PL_na);
        if (items > 1) {
            if (!SvOK((SV*) ST(1))) arg2 = 0;
            else arg2 = (char *) SvPV(ST(1), PL_na);
        }
        if (items > 2) {
            if (!SvOK((SV*) ST(2))) arg3 = 0;
            else arg3 = (char *) SvPV(ST(2), PL_na);
        }
        if (items > 3) {
            {
                if (SWIG_ConvertPtr(ST(3), (void **) &arg4, SWIGTYPE_p_SWDisplay,0) < 0) {
                    SWIG_croak("Type error in argument 4 of new_RawLD4. Expected _p_SWDisplay");
                }
            }
        }
        if (items > 4) {
            {
                SWTextEncoding * argp;
                if (SWIG_ConvertPtr(ST(4),(void **) &argp, SWIGTYPE_p_SWTextEncoding,0) < 0) {
                    SWIG_croak("Type error in argument 5 of new_RawLD4. Expected _p_SWTextEncoding");
                }
                arg5 = *argp;
            }
        }
        if (items > 5) {
            {
                SWTextDirection * argp;
                if (SWIG_ConvertPtr(ST(5),(void **) &argp, SWIGTYPE_p_SWTextDirection,0) < 0) {
                    SWIG_croak("Type error in argument 6 of new_RawLD4. Expected _p_SWTextDirection");
                }
                arg6 = *argp;
            }
        }
        if (items > 6) {
            {
                SWTextMarkup * argp;
                if (SWIG_ConvertPtr(ST(6),(void **) &argp, SWIGTYPE_p_SWTextMarkup,0) < 0) {
                    SWIG_croak("Type error in argument 7 of new_RawLD4. Expected _p_SWTextMarkup");
                }
                arg7 = *argp;
            }
        }
        if (items > 7) {
            if (!SvOK((SV*) ST(7))) arg8 = 0;
            else arg8 = (char *) SvPV(ST(7), PL_na);
        }
        result = (RawLD4 *)new RawLD4((char const *)arg1,(char const *)arg2,(char const *)arg3,arg4,arg5,arg6,arg7,(char const *)arg8);
        
        ST(argvi) = sv_newmortal();
        SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_RawLD4,0);
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}


XS(_wrap_delete_RawLD4) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        RawLD4 *arg1 = (RawLD4 *) 0 ;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 1) || (items > 1)) {
            SWIG_croak("Usage: delete_RawLD4(self);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_RawLD4,0) < 0) {
                SWIG_croak("Type error in argument 1 of delete_RawLD4. Expected _p_RawLD4");
            }
        }
        delete arg1;
        
        
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}


XS(_wrap_RawLD4_createModule) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        char *arg1 ;
        char result;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 1) || (items > 1)) {
            SWIG_croak("Usage: RawLD4_createModule(path);");
        }
        if (!SvOK((SV*) ST(0))) arg1 = 0;
        else arg1 = (char *) SvPV(ST(0), PL_na);
        result = (char)RawLD4::createModule((char const *)arg1);
        
        ST(argvi) = sv_newmortal();
        sv_setpvn((SV*)ST(argvi++), &result, 1);
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}


XS(_wrap_new_zLD) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        char *arg1 ;
        char *arg2 = (char *) 0 ;
        char *arg3 = (char *) 0 ;
        long arg4 = (long) 200 ;
        SWCompress *arg5 = (SWCompress *) 0 ;
        SWDisplay *arg6 = (SWDisplay *) 0 ;
        SWTextEncoding arg7 = (SWTextEncoding) ENC_UNKNOWN ;
        SWTextDirection arg8 = (SWTextDirection) DIRECTION_LTR ;
        SWTextMarkup arg9 = (SWTextMarkup) FMT_UNKNOWN ;
        char *arg10 = (char *) 0 ;
        zLD *result;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 1) || (items > 10)) {
            SWIG_croak("Usage: new_zLD(ipath,iname,idesc,blockCount,icomp,idisp,encoding,dir,markup,ilang);");
        }
        if (!SvOK((SV*) ST(0))) arg1 = 0;
        else arg1 = (char *) SvPV(ST(0), PL_na);
        if (items > 1) {
            if (!SvOK((SV*) ST(1))) arg2 = 0;
            else arg2 = (char *) SvPV(ST(1), PL_na);
        }
        if (items > 2) {
            if (!SvOK((SV*) ST(2))) arg3 = 0;
            else arg3 = (char *) SvPV(ST(2), PL_na);
        }
        if (items > 3) {
            arg4 = (long) SvIV(ST(3));
        }
        if (items > 4) {
            {
                if (SWIG_ConvertPtr(ST(4), (void **) &arg5, SWIGTYPE_p_SWCompress,0) < 0) {
                    SWIG_croak("Type error in argument 5 of new_zLD. Expected _p_SWCompress");
                }
            }
        }
        if (items > 5) {
            {
                if (SWIG_ConvertPtr(ST(5), (void **) &arg6, SWIGTYPE_p_SWDisplay,0) < 0) {
                    SWIG_croak("Type error in argument 6 of new_zLD. Expected _p_SWDisplay");
                }
            }
        }
        if (items > 6) {
            {
                SWTextEncoding * argp;
                if (SWIG_ConvertPtr(ST(6),(void **) &argp, SWIGTYPE_p_SWTextEncoding,0) < 0) {
                    SWIG_croak("Type error in argument 7 of new_zLD. Expected _p_SWTextEncoding");
                }
                arg7 = *argp;
            }
        }
        if (items > 7) {
            {
                SWTextDirection * argp;
                if (SWIG_ConvertPtr(ST(7),(void **) &argp, SWIGTYPE_p_SWTextDirection,0) < 0) {
                    SWIG_croak("Type error in argument 8 of new_zLD. Expected _p_SWTextDirection");
                }
                arg8 = *argp;
            }
        }
        if (items > 8) {
            {
                SWTextMarkup * argp;
                if (SWIG_ConvertPtr(ST(8),(void **) &argp, SWIGTYPE_p_SWTextMarkup,0) < 0) {
                    SWIG_croak("Type error in argument 9 of new_zLD. Expected _p_SWTextMarkup");
                }
                arg9 = *argp;
            }
        }
        if (items > 9) {
            if (!SvOK((SV*) ST(9))) arg10 = 0;
            else arg10 = (char *) SvPV(ST(9), PL_na);
        }
        result = (zLD *)new zLD((char const *)arg1,(char const *)arg2,(char const *)arg3,arg4,arg5,arg6,arg7,arg8,arg9,(char const *)arg10);
        
        ST(argvi) = sv_newmortal();
        SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_zLD,0);
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}


XS(_wrap_delete_zLD) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        zLD *arg1 = (zLD *) 0 ;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 1) || (items > 1)) {
            SWIG_croak("Usage: delete_zLD(self);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_zLD,0) < 0) {
                SWIG_croak("Type error in argument 1 of delete_zLD. Expected _p_zLD");
            }
        }
        delete arg1;
        
        
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}


XS(_wrap_zLD_createModule) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        char *arg1 ;
        char result;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 1) || (items > 1)) {
            SWIG_croak("Usage: zLD_createModule(path);");
        }
        if (!SvOK((SV*) ST(0))) arg1 = 0;
        else arg1 = (char *) SvPV(ST(0), PL_na);
        result = (char)zLD::createModule((char const *)arg1);
        
        ST(argvi) = sv_newmortal();
        sv_setpvn((SV*)ST(argvi++), &result, 1);
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}


XS(_wrap_new_SWCompress) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        SWCompress *result;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 0) || (items > 0)) {
            SWIG_croak("Usage: new_SWCompress();");
        }
        result = (SWCompress *)new SWCompress();
        
        ST(argvi) = sv_newmortal();
        SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_SWCompress,0);
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}


XS(_wrap_delete_SWCompress) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        SWCompress *arg1 = (SWCompress *) 0 ;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 1) || (items > 1)) {
            SWIG_croak("Usage: delete_SWCompress(self);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_SWCompress,0) < 0) {
                SWIG_croak("Type error in argument 1 of delete_SWCompress. Expected _p_SWCompress");
            }
        }
        delete arg1;
        
        
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}


XS(_wrap_SWCompress_Buf) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        SWCompress *arg1 = (SWCompress *) 0 ;
        char *arg2 = (char *) 0 ;
        unsigned long *arg3 = (unsigned long *) 0 ;
        char *result;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 1) || (items > 3)) {
            SWIG_croak("Usage: SWCompress_Buf(self,buf,len);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_SWCompress,0) < 0) {
                SWIG_croak("Type error in argument 1 of SWCompress_Buf. Expected _p_SWCompress");
            }
        }
        if (items > 1) {
            if (!SvOK((SV*) ST(1))) arg2 = 0;
            else arg2 = (char *) SvPV(ST(1), PL_na);
        }
        if (items > 2) {
            {
                if (SWIG_ConvertPtr(ST(2), (void **) &arg3, SWIGTYPE_p_unsigned_long,0) < 0) {
                    SWIG_croak("Type error in argument 3 of SWCompress_Buf. Expected _p_unsigned_long");
                }
            }
        }
        result = (char *)(arg1)->Buf((char const *)arg2,arg3);
        
        ST(argvi) = sv_newmortal();
        if (result) {
            sv_setpv((SV*)ST(argvi++), (char *) result);
        }else {
            sv_setsv((SV*)ST(argvi++), &PL_sv_undef);
        }
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}


XS(_wrap_SWCompress_zBuf) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        SWCompress *arg1 = (SWCompress *) 0 ;
        unsigned long *arg2 = (unsigned long *) 0 ;
        char *arg3 = (char *) 0 ;
        char *result;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 2) || (items > 3)) {
            SWIG_croak("Usage: SWCompress_zBuf(self,len,buf);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_SWCompress,0) < 0) {
                SWIG_croak("Type error in argument 1 of SWCompress_zBuf. Expected _p_SWCompress");
            }
        }
        {
            if (SWIG_ConvertPtr(ST(1), (void **) &arg2, SWIGTYPE_p_unsigned_long,0) < 0) {
                SWIG_croak("Type error in argument 2 of SWCompress_zBuf. Expected _p_unsigned_long");
            }
        }
        if (items > 2) {
            if (!SvOK((SV*) ST(2))) arg3 = 0;
            else arg3 = (char *) SvPV(ST(2), PL_na);
        }
        result = (char *)(arg1)->zBuf(arg2,arg3);
        
        ST(argvi) = sv_newmortal();
        if (result) {
            sv_setpv((SV*)ST(argvi++), (char *) result);
        }else {
            sv_setsv((SV*)ST(argvi++), &PL_sv_undef);
        }
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}


XS(_wrap_SWCompress_GetChars) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        SWCompress *arg1 = (SWCompress *) 0 ;
        char *arg2 ;
        unsigned long arg3 ;
        unsigned long result;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 3) || (items > 3)) {
            SWIG_croak("Usage: SWCompress_GetChars(self,buf,len);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_SWCompress,0) < 0) {
                SWIG_croak("Type error in argument 1 of SWCompress_GetChars. Expected _p_SWCompress");
            }
        }
        if (!SvOK((SV*) ST(1))) arg2 = 0;
        else arg2 = (char *) SvPV(ST(1), PL_na);
        arg3 = (unsigned long) SvUV(ST(2));
        result = (unsigned long)(arg1)->GetChars(arg2,arg3);
        
        ST(argvi) = sv_newmortal();
        sv_setuv(ST(argvi++), (UV) result);
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}


XS(_wrap_SWCompress_SendChars) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        SWCompress *arg1 = (SWCompress *) 0 ;
        char *arg2 ;
        unsigned long arg3 ;
        unsigned long result;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 3) || (items > 3)) {
            SWIG_croak("Usage: SWCompress_SendChars(self,buf,len);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_SWCompress,0) < 0) {
                SWIG_croak("Type error in argument 1 of SWCompress_SendChars. Expected _p_SWCompress");
            }
        }
        if (!SvOK((SV*) ST(1))) arg2 = 0;
        else arg2 = (char *) SvPV(ST(1), PL_na);
        arg3 = (unsigned long) SvUV(ST(2));
        result = (unsigned long)(arg1)->SendChars(arg2,arg3);
        
        ST(argvi) = sv_newmortal();
        sv_setuv(ST(argvi++), (UV) result);
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}


XS(_wrap_SWCompress_Encode) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        SWCompress *arg1 = (SWCompress *) 0 ;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 1) || (items > 1)) {
            SWIG_croak("Usage: SWCompress_Encode(self);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_SWCompress,0) < 0) {
                SWIG_croak("Type error in argument 1 of SWCompress_Encode. Expected _p_SWCompress");
            }
        }
        (arg1)->Encode();
        
        
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}


XS(_wrap_SWCompress_Decode) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        SWCompress *arg1 = (SWCompress *) 0 ;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 1) || (items > 1)) {
            SWIG_croak("Usage: SWCompress_Decode(self);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_SWCompress,0) < 0) {
                SWIG_croak("Type error in argument 1 of SWCompress_Decode. Expected _p_SWCompress");
            }
        }
        (arg1)->Decode();
        
        
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}


XS(_wrap_new_LZSSCompress) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        LZSSCompress *result;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 0) || (items > 0)) {
            SWIG_croak("Usage: new_LZSSCompress();");
        }
        result = (LZSSCompress *)new LZSSCompress();
        
        ST(argvi) = sv_newmortal();
        SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_LZSSCompress,0);
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}


XS(_wrap_delete_LZSSCompress) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        LZSSCompress *arg1 = (LZSSCompress *) 0 ;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 1) || (items > 1)) {
            SWIG_croak("Usage: delete_LZSSCompress(self);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_LZSSCompress,0) < 0) {
                SWIG_croak("Type error in argument 1 of delete_LZSSCompress. Expected _p_LZSSCompress");
            }
        }
        delete arg1;
        
        
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}


XS(_wrap_LZSSCompress_Encode) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        LZSSCompress *arg1 = (LZSSCompress *) 0 ;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 1) || (items > 1)) {
            SWIG_croak("Usage: LZSSCompress_Encode(self);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_LZSSCompress,0) < 0) {
                SWIG_croak("Type error in argument 1 of LZSSCompress_Encode. Expected _p_LZSSCompress");
            }
        }
        (arg1)->Encode();
        
        
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}


XS(_wrap_LZSSCompress_Decode) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        LZSSCompress *arg1 = (LZSSCompress *) 0 ;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 1) || (items > 1)) {
            SWIG_croak("Usage: LZSSCompress_Decode(self);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_LZSSCompress,0) < 0) {
                SWIG_croak("Type error in argument 1 of LZSSCompress_Decode. Expected _p_LZSSCompress");
            }
        }
        (arg1)->Decode();
        
        
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}


XS(_wrap_new_ZipCompress) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        ZipCompress *result;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 0) || (items > 0)) {
            SWIG_croak("Usage: new_ZipCompress();");
        }
        result = (ZipCompress *)new ZipCompress();
        
        ST(argvi) = sv_newmortal();
        SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_ZipCompress,0);
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}


XS(_wrap_delete_ZipCompress) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        ZipCompress *arg1 = (ZipCompress *) 0 ;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 1) || (items > 1)) {
            SWIG_croak("Usage: delete_ZipCompress(self);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_ZipCompress,0) < 0) {
                SWIG_croak("Type error in argument 1 of delete_ZipCompress. Expected _p_ZipCompress");
            }
        }
        delete arg1;
        
        
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}


XS(_wrap_ZipCompress_Encode) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        ZipCompress *arg1 = (ZipCompress *) 0 ;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 1) || (items > 1)) {
            SWIG_croak("Usage: ZipCompress_Encode(self);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_ZipCompress,0) < 0) {
                SWIG_croak("Type error in argument 1 of ZipCompress_Encode. Expected _p_ZipCompress");
            }
        }
        (arg1)->Encode();
        
        
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}


XS(_wrap_ZipCompress_Decode) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        ZipCompress *arg1 = (ZipCompress *) 0 ;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 1) || (items > 1)) {
            SWIG_croak("Usage: ZipCompress_Decode(self);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_ZipCompress,0) < 0) {
                SWIG_croak("Type error in argument 1 of ZipCompress_Decode. Expected _p_ZipCompress");
            }
        }
        (arg1)->Decode();
        
        
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}


XS(_wrap_new_SWBuf__SWIG_0) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        char *arg1 = (char *) 0 ;
        SWBuf *result;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 0) || (items > 1)) {
            SWIG_croak("Usage: new_SWBuf(initVal);");
        }
        if (items > 0) {
            if (!SvOK((SV*) ST(0))) arg1 = 0;
            else arg1 = (char *) SvPV(ST(0), PL_na);
        }
        result = (SWBuf *)new SWBuf((char const *)arg1);
        
        ST(argvi) = sv_newmortal();
        SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_SWBuf,0);
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}


XS(_wrap_new_SWBuf__SWIG_1) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        char arg1 ;
        SWBuf *result;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 1) || (items > 1)) {
            SWIG_croak("Usage: new_SWBuf(initVal);");
        }
        arg1 = (char) *SvPV(ST(0),PL_na);
        result = (SWBuf *)new SWBuf(arg1);
        
        ST(argvi) = sv_newmortal();
        SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_SWBuf,0);
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}


XS(_wrap_new_SWBuf__SWIG_2) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        SWBuf *arg1 = 0 ;
        SWBuf *result;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 1) || (items > 1)) {
            SWIG_croak("Usage: new_SWBuf(other);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_SWBuf,0) < 0) {
                SWIG_croak("Type error in argument 1 of new_SWBuf. Expected _p_SWBuf");
            }
        }
        result = (SWBuf *)new SWBuf((SWBuf const &)*arg1);
        
        ST(argvi) = sv_newmortal();
        SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_SWBuf,0);
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}


XS(_wrap_new_SWBuf) {
    dXSARGS;
    
    if ((items >= 0) && (items <= 1)) {
        int _v;
        if (items <= 0) {
            (*PL_markstack_ptr++);SWIG_CALLXS(_wrap_new_SWBuf__SWIG_0); return;
        }
        {
            _v = SvPOK(ST(0)) ? 1 : 0;
        }
        if (_v) {
            (*PL_markstack_ptr++);SWIG_CALLXS(_wrap_new_SWBuf__SWIG_0); return;
        }
    }
    if (items == 1) {
        int _v;
        {
            void *tmp;
            if (SWIG_ConvertPtr(ST(0), (void **) &tmp, SWIGTYPE_p_SWBuf, 0) == -1) {
                _v = 0;
            }else {
                _v = 1;
            }
        }
        if (_v) {
            (*PL_markstack_ptr++);SWIG_CALLXS(_wrap_new_SWBuf__SWIG_2); return;
        }
    }
    if (items == 1) {
        int _v;
        {
            _v = SvPOK(ST(0)) ? 1 : 0;
        }
        if (_v) {
            (*PL_markstack_ptr++);SWIG_CALLXS(_wrap_new_SWBuf__SWIG_1); return;
        }
    }
    
    croak("No matching function for overloaded 'new_SWBuf'");
    XSRETURN(0);
}


XS(_wrap_delete_SWBuf) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        SWBuf *arg1 = (SWBuf *) 0 ;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 1) || (items > 1)) {
            SWIG_croak("Usage: delete_SWBuf(self);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_SWBuf,0) < 0) {
                SWIG_croak("Type error in argument 1 of delete_SWBuf. Expected _p_SWBuf");
            }
        }
        delete arg1;
        
        
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}


XS(_wrap_SWBuf_setFillByte) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        SWBuf *arg1 = (SWBuf *) 0 ;
        char arg2 ;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 2) || (items > 2)) {
            SWIG_croak("Usage: SWBuf_setFillByte(self,ch);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_SWBuf,0) < 0) {
                SWIG_croak("Type error in argument 1 of SWBuf_setFillByte. Expected _p_SWBuf");
            }
        }
        arg2 = (char) *SvPV(ST(1),PL_na);
        (arg1)->setFillByte(arg2);
        
        
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}


XS(_wrap_SWBuf_getFillByte) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        SWBuf *arg1 = (SWBuf *) 0 ;
        char result;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 1) || (items > 1)) {
            SWIG_croak("Usage: SWBuf_getFillByte(self);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_SWBuf,0) < 0) {
                SWIG_croak("Type error in argument 1 of SWBuf_getFillByte. Expected _p_SWBuf");
            }
        }
        result = (char)(arg1)->getFillByte();
        
        ST(argvi) = sv_newmortal();
        sv_setpvn((SV*)ST(argvi++), &result, 1);
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}


XS(_wrap_SWBuf_c_str) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        SWBuf *arg1 = (SWBuf *) 0 ;
        char *result;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 1) || (items > 1)) {
            SWIG_croak("Usage: SWBuf_c_str(self);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_SWBuf,0) < 0) {
                SWIG_croak("Type error in argument 1 of SWBuf_c_str. Expected _p_SWBuf");
            }
        }
        result = (char *)((SWBuf const *)arg1)->c_str();
        
        ST(argvi) = sv_newmortal();
        if (result) {
            sv_setpv((SV*)ST(argvi++), (char *) result);
        }else {
            sv_setsv((SV*)ST(argvi++), &PL_sv_undef);
        }
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}


XS(_wrap_SWBuf_charAt) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        SWBuf *arg1 = (SWBuf *) 0 ;
        unsigned int arg2 ;
        char *result;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 2) || (items > 2)) {
            SWIG_croak("Usage: SWBuf_charAt(self,pos);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_SWBuf,0) < 0) {
                SWIG_croak("Type error in argument 1 of SWBuf_charAt. Expected _p_SWBuf");
            }
        }
        arg2 = (unsigned int) SvUV(ST(1));
        {
            char &_result_ref = (arg1)->charAt(arg2);
            result = (char *) &_result_ref;
        }
        
        ST(argvi) = sv_newmortal();
        SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_char,0);
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}


XS(_wrap_SWBuf_size) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        SWBuf *arg1 = (SWBuf *) 0 ;
        unsigned int result;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 1) || (items > 1)) {
            SWIG_croak("Usage: SWBuf_size(self);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_SWBuf,0) < 0) {
                SWIG_croak("Type error in argument 1 of SWBuf_size. Expected _p_SWBuf");
            }
        }
        result = (unsigned int)((SWBuf const *)arg1)->size();
        
        ST(argvi) = sv_newmortal();
        sv_setuv(ST(argvi++), (UV) result);
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}


XS(_wrap_SWBuf_length) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        SWBuf *arg1 = (SWBuf *) 0 ;
        unsigned int result;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 1) || (items > 1)) {
            SWIG_croak("Usage: SWBuf_length(self);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_SWBuf,0) < 0) {
                SWIG_croak("Type error in argument 1 of SWBuf_length. Expected _p_SWBuf");
            }
        }
        result = (unsigned int)((SWBuf const *)arg1)->length();
        
        ST(argvi) = sv_newmortal();
        sv_setuv(ST(argvi++), (UV) result);
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}


XS(_wrap_SWBuf_set__SWIG_0) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        SWBuf *arg1 = (SWBuf *) 0 ;
        char *arg2 ;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 2) || (items > 2)) {
            SWIG_croak("Usage: SWBuf_set(self,newVal);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_SWBuf,0) < 0) {
                SWIG_croak("Type error in argument 1 of SWBuf_set. Expected _p_SWBuf");
            }
        }
        if (!SvOK((SV*) ST(1))) arg2 = 0;
        else arg2 = (char *) SvPV(ST(1), PL_na);
        (arg1)->set((char const *)arg2);
        
        
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}


XS(_wrap_SWBuf_set__SWIG_1) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        SWBuf *arg1 = (SWBuf *) 0 ;
        SWBuf *arg2 = 0 ;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 2) || (items > 2)) {
            SWIG_croak("Usage: SWBuf_set(self,newVal);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_SWBuf,0) < 0) {
                SWIG_croak("Type error in argument 1 of SWBuf_set. Expected _p_SWBuf");
            }
        }
        {
            if (SWIG_ConvertPtr(ST(1), (void **) &arg2, SWIGTYPE_p_SWBuf,0) < 0) {
                SWIG_croak("Type error in argument 2 of SWBuf_set. Expected _p_SWBuf");
            }
        }
        (arg1)->set((SWBuf const &)*arg2);
        
        
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}


XS(_wrap_SWBuf_set) {
    dXSARGS;
    
    if (items == 2) {
        int _v;
        {
            void *tmp;
            if (SWIG_ConvertPtr(ST(0), (void **) &tmp, SWIGTYPE_p_SWBuf, 0) == -1) {
                _v = 0;
            }else {
                _v = 1;
            }
        }
        if (_v) {
            {
                void *tmp;
                if (SWIG_ConvertPtr(ST(1), (void **) &tmp, SWIGTYPE_p_SWBuf, 0) == -1) {
                    _v = 0;
                }else {
                    _v = 1;
                }
            }
            if (_v) {
                (*PL_markstack_ptr++);SWIG_CALLXS(_wrap_SWBuf_set__SWIG_1); return;
            }
        }
    }
    if (items == 2) {
        int _v;
        {
            void *tmp;
            if (SWIG_ConvertPtr(ST(0), (void **) &tmp, SWIGTYPE_p_SWBuf, 0) == -1) {
                _v = 0;
            }else {
                _v = 1;
            }
        }
        if (_v) {
            {
                _v = SvPOK(ST(1)) ? 1 : 0;
            }
            if (_v) {
                (*PL_markstack_ptr++);SWIG_CALLXS(_wrap_SWBuf_set__SWIG_0); return;
            }
        }
    }
    
    croak("No matching function for overloaded 'SWBuf_set'");
    XSRETURN(0);
}


XS(_wrap_SWBuf_setSize) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        SWBuf *arg1 = (SWBuf *) 0 ;
        unsigned int arg2 ;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 2) || (items > 2)) {
            SWIG_croak("Usage: SWBuf_setSize(self,len);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_SWBuf,0) < 0) {
                SWIG_croak("Type error in argument 1 of SWBuf_setSize. Expected _p_SWBuf");
            }
        }
        arg2 = (unsigned int) SvUV(ST(1));
        (arg1)->setSize(arg2);
        
        
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}


XS(_wrap_SWBuf_append__SWIG_0) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        SWBuf *arg1 = (SWBuf *) 0 ;
        char *arg2 ;
        int arg3 = (int) -1 ;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 2) || (items > 3)) {
            SWIG_croak("Usage: SWBuf_append(self,str,max);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_SWBuf,0) < 0) {
                SWIG_croak("Type error in argument 1 of SWBuf_append. Expected _p_SWBuf");
            }
        }
        if (!SvOK((SV*) ST(1))) arg2 = 0;
        else arg2 = (char *) SvPV(ST(1), PL_na);
        if (items > 2) {
            arg3 = (int) SvIV(ST(2));
        }
        (arg1)->append((char const *)arg2,arg3);
        
        
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}


XS(_wrap_SWBuf_append__SWIG_1) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        SWBuf *arg1 = (SWBuf *) 0 ;
        SWBuf *arg2 = 0 ;
        int arg3 = (int) -1 ;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 2) || (items > 3)) {
            SWIG_croak("Usage: SWBuf_append(self,str,max);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_SWBuf,0) < 0) {
                SWIG_croak("Type error in argument 1 of SWBuf_append. Expected _p_SWBuf");
            }
        }
        {
            if (SWIG_ConvertPtr(ST(1), (void **) &arg2, SWIGTYPE_p_SWBuf,0) < 0) {
                SWIG_croak("Type error in argument 2 of SWBuf_append. Expected _p_SWBuf");
            }
        }
        if (items > 2) {
            arg3 = (int) SvIV(ST(2));
        }
        (arg1)->append((SWBuf const &)*arg2,arg3);
        
        
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}


XS(_wrap_SWBuf_append__SWIG_2) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        SWBuf *arg1 = (SWBuf *) 0 ;
        char arg2 ;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 2) || (items > 2)) {
            SWIG_croak("Usage: SWBuf_append(self,ch);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_SWBuf,0) < 0) {
                SWIG_croak("Type error in argument 1 of SWBuf_append. Expected _p_SWBuf");
            }
        }
        arg2 = (char) *SvPV(ST(1),PL_na);
        (arg1)->append(arg2);
        
        
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}


XS(_wrap_SWBuf_append) {
    dXSARGS;
    
    if ((items >= 2) && (items <= 3)) {
        int _v;
        {
            void *tmp;
            if (SWIG_ConvertPtr(ST(0), (void **) &tmp, SWIGTYPE_p_SWBuf, 0) == -1) {
                _v = 0;
            }else {
                _v = 1;
            }
        }
        if (_v) {
            {
                void *tmp;
                if (SWIG_ConvertPtr(ST(1), (void **) &tmp, SWIGTYPE_p_SWBuf, 0) == -1) {
                    _v = 0;
                }else {
                    _v = 1;
                }
            }
            if (_v) {
                if (items <= 2) {
                    (*PL_markstack_ptr++);SWIG_CALLXS(_wrap_SWBuf_append__SWIG_1); return;
                }
                {
                    _v = SvIOK(ST(2)) ? 1 : 0;
                }
                if (_v) {
                    (*PL_markstack_ptr++);SWIG_CALLXS(_wrap_SWBuf_append__SWIG_1); return;
                }
            }
        }
    }
    if (items == 2) {
        int _v;
        {
            void *tmp;
            if (SWIG_ConvertPtr(ST(0), (void **) &tmp, SWIGTYPE_p_SWBuf, 0) == -1) {
                _v = 0;
            }else {
                _v = 1;
            }
        }
        if (_v) {
            {
                _v = SvPOK(ST(1)) ? 1 : 0;
            }
            if (_v) {
                (*PL_markstack_ptr++);SWIG_CALLXS(_wrap_SWBuf_append__SWIG_2); return;
            }
        }
    }
    if ((items >= 2) && (items <= 3)) {
        int _v;
        {
            void *tmp;
            if (SWIG_ConvertPtr(ST(0), (void **) &tmp, SWIGTYPE_p_SWBuf, 0) == -1) {
                _v = 0;
            }else {
                _v = 1;
            }
        }
        if (_v) {
            {
                _v = SvPOK(ST(1)) ? 1 : 0;
            }
            if (_v) {
                if (items <= 2) {
                    (*PL_markstack_ptr++);SWIG_CALLXS(_wrap_SWBuf_append__SWIG_0); return;
                }
                {
                    _v = SvIOK(ST(2)) ? 1 : 0;
                }
                if (_v) {
                    (*PL_markstack_ptr++);SWIG_CALLXS(_wrap_SWBuf_append__SWIG_0); return;
                }
            }
        }
    }
    
    croak("No matching function for overloaded 'SWBuf_append'");
    XSRETURN(0);
}


XS(_wrap_SWBuf_appendFormatted) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        SWBuf *arg1 = (SWBuf *) 0 ;
        char *arg2 ;
        void *arg3 = 0 ;
        int argvi = 0;
        dXSARGS;
        
        if (items < 2) {
            SWIG_croak("Usage: SWBuf_appendFormatted(self,format,...);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_SWBuf,0) < 0) {
                SWIG_croak("Type error in argument 1 of SWBuf_appendFormatted. Expected _p_SWBuf");
            }
        }
        if (!SvOK((SV*) ST(1))) arg2 = 0;
        else arg2 = (char *) SvPV(ST(1), PL_na);
        (arg1)->appendFormatted((char const *)arg2,arg3);
        
        
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}


XS(_wrap_SWBuf_getRawData) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        SWBuf *arg1 = (SWBuf *) 0 ;
        char *result;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 1) || (items > 1)) {
            SWIG_croak("Usage: SWBuf_getRawData(self);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_SWBuf,0) < 0) {
                SWIG_croak("Type error in argument 1 of SWBuf_getRawData. Expected _p_SWBuf");
            }
        }
        result = (char *)(arg1)->getRawData();
        
        ST(argvi) = sv_newmortal();
        if (result) {
            sv_setpv((SV*)ST(argvi++), (char *) result);
        }else {
            sv_setsv((SV*)ST(argvi++), &PL_sv_undef);
        }
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}


XS(_wrap_SWBuf_compare) {
    char _swigmsg[SWIG_MAX_ERRMSG] = "";
    const char *_swigerr = _swigmsg;
    {
        SWBuf *arg1 = (SWBuf *) 0 ;
        SWBuf *arg2 = 0 ;
        int result;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 2) || (items > 2)) {
            SWIG_croak("Usage: SWBuf_compare(self,other);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_SWBuf,0) < 0) {
                SWIG_croak("Type error in argument 1 of SWBuf_compare. Expected _p_SWBuf");
            }
        }
        {
            if (SWIG_ConvertPtr(ST(1), (void **) &arg2, SWIGTYPE_p_SWBuf,0) < 0) {
                SWIG_croak("Type error in argument 2 of SWBuf_compare. Expected _p_SWBuf");
            }
        }
        result = (int)((SWBuf const *)arg1)->compare((SWBuf const &)*arg2);
        
        ST(argvi) = sv_newmortal();
        sv_setiv(ST(argvi++), (IV) result);
        XSRETURN(argvi);
        fail:
        (void) _swigerr;
    }
    croak(_swigerr);
}



/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */

static void *_p_zComTo_p_SWCom(void *x) {
    return (void *)((SWCom *)  ((zCom *) x));
}
static void *_p_RawComTo_p_SWCom(void *x) {
    return (void *)((SWCom *)  ((RawCom *) x));
}
static void *_p_TreeKeyIdxTo_p_TreeKey(void *x) {
    return (void *)((TreeKey *)  ((TreeKeyIdx *) x));
}
static void *_p_RawTextTo_p_SWText(void *x) {
    return (void *)((SWText *)  ((RawText *) x));
}
static void *_p_zTextTo_p_SWText(void *x) {
    return (void *)((SWText *)  ((zText *) x));
}
static void *_p_ListKeyTo_p_SWKey(void *x) {
    return (void *)((SWKey *)  ((ListKey *) x));
}
static void *_p_TreeKeyIdxTo_p_SWKey(void *x) {
    return (void *)((SWKey *) (TreeKey *) ((TreeKeyIdx *) x));
}
static void *_p_VerseKeyTo_p_SWKey(void *x) {
    return (void *)((SWKey *)  ((VerseKey *) x));
}
static void *_p_TreeKeyTo_p_SWKey(void *x) {
    return (void *)((SWKey *)  ((TreeKey *) x));
}
static void *_p_LZSSCompressTo_p_SWCompress(void *x) {
    return (void *)((SWCompress *)  ((LZSSCompress *) x));
}
static void *_p_ZipCompressTo_p_SWCompress(void *x) {
    return (void *)((SWCompress *)  ((ZipCompress *) x));
}
static void *_p_SWComTo_p_SWModule(void *x) {
    return (void *)((SWModule *)  ((SWCom *) x));
}
static void *_p_zLDTo_p_SWModule(void *x) {
    return (void *)((SWModule *) (SWLD *) ((zLD *) x));
}
static void *_p_SWTextTo_p_SWModule(void *x) {
    return (void *)((SWModule *)  ((SWText *) x));
}
static void *_p_SWGenBookTo_p_SWModule(void *x) {
    return (void *)((SWModule *)  ((SWGenBook *) x));
}
static void *_p_RawGenBookTo_p_SWModule(void *x) {
    return (void *)((SWModule *) (SWGenBook *) ((RawGenBook *) x));
}
static void *_p_RawTextTo_p_SWModule(void *x) {
    return (void *)((SWModule *) (SWText *) ((RawText *) x));
}
static void *_p_zComTo_p_SWModule(void *x) {
    return (void *)((SWModule *) (SWCom *) ((zCom *) x));
}
static void *_p_RawLD4To_p_SWModule(void *x) {
    return (void *)((SWModule *) (SWLD *) ((RawLD4 *) x));
}
static void *_p_zTextTo_p_SWModule(void *x) {
    return (void *)((SWModule *) (SWText *) ((zText *) x));
}
static void *_p_RawComTo_p_SWModule(void *x) {
    return (void *)((SWModule *) (SWCom *) ((RawCom *) x));
}
static void *_p_SWLDTo_p_SWModule(void *x) {
    return (void *)((SWModule *)  ((SWLD *) x));
}
static void *_p_RawLDTo_p_SWModule(void *x) {
    return (void *)((SWModule *) (SWLD *) ((RawLD *) x));
}
static void *_p_RawGenBookTo_p_SWGenBook(void *x) {
    return (void *)((SWGenBook *)  ((RawGenBook *) x));
}
static void *_p_zLDTo_p_SWLD(void *x) {
    return (void *)((SWLD *)  ((zLD *) x));
}
static void *_p_RawLD4To_p_SWLD(void *x) {
    return (void *)((SWLD *)  ((RawLD4 *) x));
}
static void *_p_RawLDTo_p_SWLD(void *x) {
    return (void *)((SWLD *)  ((RawLD *) x));
}
static swig_type_info _swigt__p_SWLocale[] = {{"_p_SWLocale", 0, "SWLocale *", 0},{"_p_SWLocale"},{0}};
static swig_type_info _swigt__p_SWMgr[] = {{"Sword::SWMgr", 0, "SWMgr *", 0},{"Sword::SWMgr"},{0}};
static swig_type_info _swigt__p_SWCom[] = {{"Sword::SWCom", 0, "SWCom *", 0},{"Sword::zCom", _p_zComTo_p_SWCom},{"Sword::SWCom"},{"Sword::RawCom", _p_RawComTo_p_SWCom},{0}};
static swig_type_info _swigt__p_RawLD4[] = {{"Sword::RawLD4", 0, "RawLD4 *", 0},{"Sword::RawLD4"},{0}};
static swig_type_info _swigt__p_ListKey[] = {{"Sword::ListKey", 0, "ListKey *", 0},{"Sword::ListKey"},{0}};
static swig_type_info _swigt__p_SWKey[] = {{"Sword::SWKey", 0, "SWKey *", 0},{"Sword::SWKey"},{"Sword::ListKey", _p_ListKeyTo_p_SWKey},{"Sword::TreeKeyIdx", _p_TreeKeyIdxTo_p_SWKey},{"Sword::VerseKey", _p_VerseKeyTo_p_SWKey},{"Sword::TreeKey", _p_TreeKeyTo_p_SWKey},{0}};
static swig_type_info _swigt__p_ConfigEntMap[] = {{"_p_ConfigEntMap", 0, "ConfigEntMap *", 0},{"_p_ConfigEntMap"},{0}};
static swig_type_info _swigt__p_p_char[] = {{"_p_p_char", 0, "char **", 0},{"_p_p_char"},{0}};
static swig_type_info _swigt__p_RawLD[] = {{"Sword::RawLD", 0, "RawLD *", 0},{"Sword::RawLD"},{0}};
static swig_type_info _swigt__p_char[] = {{"_p_char", 0, "char *", 0},{"_p_char"},{0}};
static swig_type_info _swigt__p_TreeKey[] = {{"Sword::TreeKey", 0, "TreeKey *", 0},{"Sword::TreeKeyIdx", _p_TreeKeyIdxTo_p_TreeKey},{"Sword::TreeKey"},{0}};
static swig_type_info _swigt__p_StringList[] = {{"_p_StringList", 0, "StringList *", 0},{"_p_StringList"},{0}};
static swig_type_info _swigt__p_bool[] = {{"_p_bool", 0, "bool *", 0},{"_p_bool"},{0}};
static swig_type_info _swigt__p_SWFilterMgr[] = {{"Sword::SWFilterMgr", 0, "SWFilterMgr *", 0},{"Sword::SWFilterMgr"},{0}};
static swig_type_info _swigt__p_SWLD[] = {{"Sword::SWLD", 0, "SWLD *", 0},{"Sword::zLD", _p_zLDTo_p_SWLD},{"Sword::SWLD"},{"Sword::RawLD4", _p_RawLD4To_p_SWLD},{"Sword::RawLD", _p_RawLDTo_p_SWLD},{0}};
static swig_type_info _swigt__p_SWTextDirection[] = {{"_p_SWTextDirection", 0, "SWTextDirection *", 0},{"_p_SWTextDirection"},{0}};
static swig_type_info _swigt__p_RawText[] = {{"Sword::RawText", 0, "RawText *", 0},{"Sword::RawText"},{0}};
static swig_type_info _swigt__p_f_char_p_void__void[] = {{"_p_f_char_p_void__void", 0, "void (*)(char,void *)", 0},{"_p_f_char_p_void__void"},{0}};
static swig_type_info _swigt__p_VerseKey[] = {{"Sword::VerseKey", 0, "VerseKey *", 0},{"Sword::VerseKey"},{0}};
static swig_type_info _swigt__p_SWBuf[] = {{"Sword::SWBuf", 0, "SWBuf *", 0},{"Sword::SWBuf"},{0}};
static swig_type_info _swigt__p_ModMap[] = {{"_p_ModMap", 0, "ModMap *", 0},{"_p_ModMap"},{0}};
static swig_type_info _swigt__p_zCom[] = {{"Sword::zCom", 0, "zCom *", 0},{"Sword::zCom"},{0}};
static swig_type_info _swigt__p_SectionMap[] = {{"_p_SectionMap", 0, "SectionMap *", 0},{"_p_SectionMap"},{0}};
static swig_type_info _swigt__p_SWDisplay[] = {{"_p_SWDisplay", 0, "SWDisplay *", 0},{"_p_SWDisplay"},{0}};
static swig_type_info _swigt__p_AttributeTypeList[] = {{"_p_AttributeTypeList", 0, "AttributeTypeList *", 0},{"_p_AttributeTypeList"},{0}};
static swig_type_info _swigt__p_SWText[] = {{"Sword::SWText", 0, "SWText *", 0},{"Sword::SWText"},{"Sword::RawText", _p_RawTextTo_p_SWText},{"Sword::zText", _p_zTextTo_p_SWText},{0}};
static swig_type_info _swigt__p_std__listTSWBuf_t[] = {{"_p_std__listTSWBuf_t", 0, "std::list<SWBuf > *", 0},{"_p_std__listTSWBuf_t"},{0}};
static swig_type_info _swigt__p_TreeKeyIdx[] = {{"Sword::TreeKeyIdx", 0, "TreeKeyIdx *", 0},{"Sword::TreeKeyIdx"},{0}};
static swig_type_info _swigt__p_SWCompress[] = {{"Sword::SWCompress", 0, "SWCompress *", 0},{"Sword::SWCompress"},{"Sword::LZSSCompress", _p_LZSSCompressTo_p_SWCompress},{"Sword::ZipCompress", _p_ZipCompressTo_p_SWCompress},{0}};
static swig_type_info _swigt__p_LZSSCompress[] = {{"Sword::LZSSCompress", 0, "LZSSCompress *", 0},{"Sword::LZSSCompress"},{0}};
static swig_type_info _swigt__p_ZipCompress[] = {{"Sword::ZipCompress", 0, "ZipCompress *", 0},{"Sword::ZipCompress"},{0}};
static swig_type_info _swigt__p_SW_POSITION[] = {{"Sword::SW_POSITION", 0, "SW_POSITION *", 0},{"Sword::SW_POSITION"},{0}};
static swig_type_info _swigt__p_SWModule[] = {{"Sword::SWModule", 0, "SWModule *", 0},{"Sword::SWModule"},{"Sword::SWGenBook", _p_SWGenBookTo_p_SWModule},{"Sword::RawGenBook", _p_RawGenBookTo_p_SWModule},{"Sword::SWText", _p_SWTextTo_p_SWModule},{"Sword::RawText", _p_RawTextTo_p_SWModule},{"Sword::zLD", _p_zLDTo_p_SWModule},{"Sword::zCom", _p_zComTo_p_SWModule},{"Sword::zText", _p_zTextTo_p_SWModule},{"Sword::RawLD4", _p_RawLD4To_p_SWModule},{"Sword::SWLD", _p_SWLDTo_p_SWModule},{"Sword::RawLD", _p_RawLDTo_p_SWModule},{"Sword::SWCom", _p_SWComTo_p_SWModule},{"Sword::RawCom", _p_RawComTo_p_SWModule},{0}};
static swig_type_info _swigt__p_zLD[] = {{"Sword::zLD", 0, "zLD *", 0},{"Sword::zLD"},{0}};
static swig_type_info _swigt__p_SWGenBook[] = {{"Sword::SWGenBook", 0, "SWGenBook *", 0},{"Sword::SWGenBook"},{"Sword::RawGenBook", _p_RawGenBookTo_p_SWGenBook},{0}};
static swig_type_info _swigt__p_RawCom[] = {{"Sword::RawCom", 0, "RawCom *", 0},{"Sword::RawCom"},{0}};
static swig_type_info _swigt__p_RawGenBook[] = {{"Sword::RawGenBook", 0, "RawGenBook *", 0},{"Sword::RawGenBook"},{0}};
static swig_type_info _swigt__p_SWConfig[] = {{"Sword::SWConfig", 0, "SWConfig *", 0},{"Sword::SWConfig"},{0}};
static swig_type_info _swigt__p_LocaleMgr[] = {{"Sword::LocaleMgr", 0, "LocaleMgr *", 0},{"Sword::LocaleMgr"},{0}};
static swig_type_info _swigt__p_int[] = {{"_p_int", 0, "int *", 0},{"_p_int"},{0}};
static swig_type_info _swigt__p_SWTextMarkup[] = {{"_p_SWTextMarkup", 0, "SWTextMarkup *", 0},{"_p_SWTextMarkup"},{0}};
static swig_type_info _swigt__p_zText[] = {{"Sword::zText", 0, "zText *", 0},{"Sword::zText"},{0}};
static swig_type_info _swigt__p_SWTextEncoding[] = {{"_p_SWTextEncoding", 0, "SWTextEncoding *", 0},{"_p_SWTextEncoding"},{0}};
static swig_type_info _swigt__p_unsigned_long[] = {{"_p_unsigned_long", 0, "unsigned long *", 0},{"_p_unsigned_long"},{0}};

static swig_type_info *swig_types_initial[] = {
_swigt__p_SWLocale, 
_swigt__p_SWMgr, 
_swigt__p_SWCom, 
_swigt__p_RawLD4, 
_swigt__p_ListKey, 
_swigt__p_SWKey, 
_swigt__p_ConfigEntMap, 
_swigt__p_p_char, 
_swigt__p_RawLD, 
_swigt__p_char, 
_swigt__p_TreeKey, 
_swigt__p_StringList, 
_swigt__p_bool, 
_swigt__p_SWFilterMgr, 
_swigt__p_SWLD, 
_swigt__p_SWTextDirection, 
_swigt__p_RawText, 
_swigt__p_f_char_p_void__void, 
_swigt__p_VerseKey, 
_swigt__p_SWBuf, 
_swigt__p_ModMap, 
_swigt__p_zCom, 
_swigt__p_SectionMap, 
_swigt__p_SWDisplay, 
_swigt__p_AttributeTypeList, 
_swigt__p_SWText, 
_swigt__p_std__listTSWBuf_t, 
_swigt__p_TreeKeyIdx, 
_swigt__p_SWCompress, 
_swigt__p_LZSSCompress, 
_swigt__p_ZipCompress, 
_swigt__p_SW_POSITION, 
_swigt__p_SWModule, 
_swigt__p_zLD, 
_swigt__p_SWGenBook, 
_swigt__p_RawCom, 
_swigt__p_RawGenBook, 
_swigt__p_SWConfig, 
_swigt__p_LocaleMgr, 
_swigt__p_int, 
_swigt__p_SWTextMarkup, 
_swigt__p_zText, 
_swigt__p_SWTextEncoding, 
_swigt__p_unsigned_long, 
0
};


/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */

static swig_constant_info swig_constants[] = {
{0}
};
#ifdef __cplusplus
}
#endif
static swig_variable_info swig_variables[] = {
{0}
};
static swig_command_info swig_commands[] = {
{"Swordc::SWConfig_filename_set", _wrap_SWConfig_filename_set},
{"Swordc::SWConfig_filename_get", _wrap_SWConfig_filename_get},
{"Swordc::SWConfig_Sections_set", _wrap_SWConfig_Sections_set},
{"Swordc::SWConfig_Sections_get", _wrap_SWConfig_Sections_get},
{"Swordc::new_SWConfig", _wrap_new_SWConfig},
{"Swordc::delete_SWConfig", _wrap_delete_SWConfig},
{"Swordc::SWConfig_Load", _wrap_SWConfig_Load},
{"Swordc::SWConfig_Save", _wrap_SWConfig_Save},
{"Swordc::SWConfig_set", _wrap_SWConfig_set},
{"Swordc::SWConfig_get", _wrap_SWConfig_get},
{"Swordc::SWMgr_findConfig", _wrap_SWMgr_findConfig},
{"Swordc::SWMgr_config_set", _wrap_SWMgr_config_set},
{"Swordc::SWMgr_config_get", _wrap_SWMgr_config_get},
{"Swordc::SWMgr_sysconfig_set", _wrap_SWMgr_sysconfig_set},
{"Swordc::SWMgr_sysconfig_get", _wrap_SWMgr_sysconfig_get},
{"Swordc::SWMgr_Modules_set", _wrap_SWMgr_Modules_set},
{"Swordc::SWMgr_Modules_get", _wrap_SWMgr_Modules_get},
{"Swordc::SWMgr_prefixPath_set", _wrap_SWMgr_prefixPath_set},
{"Swordc::SWMgr_prefixPath_get", _wrap_SWMgr_prefixPath_get},
{"Swordc::SWMgr_configPath_set", _wrap_SWMgr_configPath_set},
{"Swordc::SWMgr_configPath_get", _wrap_SWMgr_configPath_get},
{"Swordc::new_SWMgr", _wrap_new_SWMgr},
{"Swordc::delete_SWMgr", _wrap_delete_SWMgr},
{"Swordc::SWMgr_Load", _wrap_SWMgr_Load},
{"Swordc::SWMgr_setGlobalOption", _wrap_SWMgr_setGlobalOption},
{"Swordc::SWMgr_getGlobalOption", _wrap_SWMgr_getGlobalOption},
{"Swordc::SWMgr_getGlobalOptionTip", _wrap_SWMgr_getGlobalOptionTip},
{"Swordc::SWMgr_getGlobalOptions", _wrap_SWMgr_getGlobalOptions},
{"Swordc::SWMgr_getGlobalOptionValues", _wrap_SWMgr_getGlobalOptionValues},
{"Swordc::SWMgr_setCipherKey", _wrap_SWMgr_setCipherKey},
{"Swordc::SWMgr_getModule", _wrap_SWMgr_getModule},
{"Swordc::SWMgr_InstallScan", _wrap_SWMgr_InstallScan},
{"Swordc::SWMgr_moduleCount", _wrap_SWMgr_moduleCount},
{"Swordc::SWMgr_getModuleAt", _wrap_SWMgr_getModuleAt},
{"Swordc::SWModule_terminateSearch_set", _wrap_SWModule_terminateSearch_set},
{"Swordc::SWModule_terminateSearch_get", _wrap_SWModule_terminateSearch_get},
{"Swordc::new_SWModule", _wrap_new_SWModule},
{"Swordc::SWModule_Error", _wrap_SWModule_Error},
{"Swordc::SWModule_isUnicode", _wrap_SWModule_isUnicode},
{"Swordc::SWModule_getConfig", _wrap_SWModule_getConfig},
{"Swordc::SWModule_getConfigEntry", _wrap_SWModule_getConfigEntry},
{"Swordc::SWModule_SetKey", _wrap_SWModule_SetKey},
{"Swordc::SWModule_Key", _wrap_SWModule_Key},
{"Swordc::SWModule_CreateKey", _wrap_SWModule_CreateKey},
{"Swordc::SWModule_KeyText", _wrap_SWModule_KeyText},
{"Swordc::SWModule_Display", _wrap_SWModule_Display},
{"Swordc::SWModule_nullPercent", _wrap_SWModule_nullPercent},
{"Swordc::SWModule_Search", _wrap_SWModule_Search},
{"Swordc::SWModule_createSearchFramework", _wrap_SWModule_createSearchFramework},
{"Swordc::SWModule_hasSearchFramework", _wrap_SWModule_hasSearchFramework},
{"Swordc::SWModule_isSearchOptimallySupported", _wrap_SWModule_isSearchOptimallySupported},
{"Swordc::SWModule_next", _wrap_SWModule_next},
{"Swordc::SWModule_prev", _wrap_SWModule_prev},
{"Swordc::SWModule_inc", _wrap_SWModule_inc},
{"Swordc::SWModule_dec", _wrap_SWModule_dec},
{"Swordc::SWModule_setPosition", _wrap_SWModule_setPosition},
{"Swordc::SWModule_top", _wrap_SWModule_top},
{"Swordc::SWModule_bottom", _wrap_SWModule_bottom},
{"Swordc::SWModule_text", _wrap_SWModule_text},
{"Swordc::SWModule_StripText", _wrap_SWModule_StripText},
{"Swordc::SWModule_getRawEntry", _wrap_SWModule_getRawEntry},
{"Swordc::SWModule_setSkipConsecutiveLinks", _wrap_SWModule_setSkipConsecutiveLinks},
{"Swordc::SWModule_getSkipConsecutiveLinks", _wrap_SWModule_getSkipConsecutiveLinks},
{"Swordc::SWModule_getEntryAttributes", _wrap_SWModule_getEntryAttributes},
{"Swordc::SWModule_processEntryAttributes", _wrap_SWModule_processEntryAttributes},
{"Swordc::SWModule_isProcessEntryAttributes", _wrap_SWModule_isProcessEntryAttributes},
{"Swordc::SWModule_Name", _wrap_SWModule_Name},
{"Swordc::SWModule_Description", _wrap_SWModule_Description},
{"Swordc::SWModule_Type", _wrap_SWModule_Type},
{"Swordc::SWModule_Direction", _wrap_SWModule_Direction},
{"Swordc::SWModule_Encoding", _wrap_SWModule_Encoding},
{"Swordc::SWModule_Markup", _wrap_SWModule_Markup},
{"Swordc::SWModule_Lang", _wrap_SWModule_Lang},
{"Swordc::SWModule_isWritable", _wrap_SWModule_isWritable},
{"Swordc::SWModule_createModule", _wrap_SWModule_createModule},
{"Swordc::SWModule_setEntry", _wrap_SWModule_setEntry},
{"Swordc::SWModule_deleteEntry", _wrap_SWModule_deleteEntry},
{"Swordc::SWModule_write", _wrap_SWModule_write},
{"Swordc::SWModule_writeLink", _wrap_SWModule_writeLink},
{"Swordc::delete_SWModule", _wrap_delete_SWModule},
{"Swordc::new_SW_POSITION", _wrap_new_SW_POSITION},
{"Swordc::delete_SW_POSITION", _wrap_delete_SW_POSITION},
{"Swordc::new_SWKey", _wrap_new_SWKey},
{"Swordc::SWKey_clone", _wrap_SWKey_clone},
{"Swordc::delete_SWKey", _wrap_delete_SWKey},
{"Swordc::SWKey_Persist", _wrap_SWKey_Persist},
{"Swordc::SWKey_setPersist", _wrap_SWKey_setPersist},
{"Swordc::SWKey_Error", _wrap_SWKey_Error},
{"Swordc::SWKey_setText", _wrap_SWKey_setText},
{"Swordc::SWKey_getText", _wrap_SWKey_getText},
{"Swordc::SWKey_getShortText", _wrap_SWKey_getShortText},
{"Swordc::SWKey_compare", _wrap_SWKey_compare},
{"Swordc::SWKey_equals", _wrap_SWKey_equals},
{"Swordc::SWKey_decrement", _wrap_SWKey_decrement},
{"Swordc::SWKey_increment", _wrap_SWKey_increment},
{"Swordc::SWKey_Traversable", _wrap_SWKey_Traversable},
{"Swordc::SWKey_Index", _wrap_SWKey_Index},
{"Swordc::SWKey_next", _wrap_SWKey_next},
{"Swordc::SWKey_prev", _wrap_SWKey_prev},
{"Swordc::SWKey_setKey", _wrap_SWKey_setKey},
{"Swordc::SWKey_toVerseKey", _wrap_SWKey_toVerseKey},
{"Swordc::new_VerseKey", _wrap_new_VerseKey},
{"Swordc::delete_VerseKey", _wrap_delete_VerseKey},
{"Swordc::VerseKey_clone", _wrap_VerseKey_clone},
{"Swordc::VerseKey_LowerBound", _wrap_VerseKey_LowerBound},
{"Swordc::VerseKey_UpperBound", _wrap_VerseKey_UpperBound},
{"Swordc::VerseKey_ClearBounds", _wrap_VerseKey_ClearBounds},
{"Swordc::VerseKey_ParseVerseList", _wrap_VerseKey_ParseVerseList},
{"Swordc::VerseKey_setText", _wrap_VerseKey_setText},
{"Swordc::VerseKey_getText", _wrap_VerseKey_getText},
{"Swordc::VerseKey_getRangeText", _wrap_VerseKey_getRangeText},
{"Swordc::VerseKey_getShortText", _wrap_VerseKey_getShortText},
{"Swordc::VerseKey_Traversable", _wrap_VerseKey_Traversable},
{"Swordc::VerseKey_decrement", _wrap_VerseKey_decrement},
{"Swordc::VerseKey_increment", _wrap_VerseKey_increment},
{"Swordc::VerseKey_getBookName", _wrap_VerseKey_getBookName},
{"Swordc::VerseKey_getBookAbbrev", _wrap_VerseKey_getBookAbbrev},
{"Swordc::VerseKey_Testament", _wrap_VerseKey_Testament},
{"Swordc::VerseKey_Book", _wrap_VerseKey_Book},
{"Swordc::VerseKey_Chapter", _wrap_VerseKey_Chapter},
{"Swordc::VerseKey_Verse", _wrap_VerseKey_Verse},
{"Swordc::VerseKey_Normalize", _wrap_VerseKey_Normalize},
{"Swordc::VerseKey_AutoNormalize", _wrap_VerseKey_AutoNormalize},
{"Swordc::VerseKey_Headings", _wrap_VerseKey_Headings},
{"Swordc::VerseKey_getOSISRef", _wrap_VerseKey_getOSISRef},
{"Swordc::VerseKey_compare", _wrap_VerseKey_compare},
{"Swordc::VerseKey__compare", _wrap_VerseKey__compare},
{"Swordc::VerseKey_setLocale", _wrap_VerseKey_setLocale},
{"Swordc::VerseKey_getLocale", _wrap_VerseKey_getLocale},
{"Swordc::VerseKey_bookCount", _wrap_VerseKey_bookCount},
{"Swordc::VerseKey_bookName", _wrap_VerseKey_bookName},
{"Swordc::VerseKey_chapterCount", _wrap_VerseKey_chapterCount},
{"Swordc::VerseKey_verseCount", _wrap_VerseKey_verseCount},
{"Swordc::new_ListKey", _wrap_new_ListKey},
{"Swordc::delete_ListKey", _wrap_delete_ListKey},
{"Swordc::ListKey_clone", _wrap_ListKey_clone},
{"Swordc::ListKey_ClearList", _wrap_ListKey_ClearList},
{"Swordc::ListKey_Count", _wrap_ListKey_Count},
{"Swordc::ListKey_Remove", _wrap_ListKey_Remove},
{"Swordc::ListKey_SetToElement", _wrap_ListKey_SetToElement},
{"Swordc::ListKey_GetElement", _wrap_ListKey_GetElement},
{"Swordc::ListKey_add", _wrap_ListKey_add},
{"Swordc::ListKey_copyFrom", _wrap_ListKey_copyFrom},
{"Swordc::ListKey_setPosition", _wrap_ListKey_setPosition},
{"Swordc::ListKey_decrement", _wrap_ListKey_decrement},
{"Swordc::ListKey_increment", _wrap_ListKey_increment},
{"Swordc::ListKey_Traversable", _wrap_ListKey_Traversable},
{"Swordc::ListKey_Index", _wrap_ListKey_Index},
{"Swordc::TreeKey_getLocalName", _wrap_TreeKey_getLocalName},
{"Swordc::TreeKey_setLocalName", _wrap_TreeKey_setLocalName},
{"Swordc::TreeKey_getUserData", _wrap_TreeKey_getUserData},
{"Swordc::TreeKey_setUserData", _wrap_TreeKey_setUserData},
{"Swordc::TreeKey_getFullName", _wrap_TreeKey_getFullName},
{"Swordc::TreeKey_root", _wrap_TreeKey_root},
{"Swordc::TreeKey_parent", _wrap_TreeKey_parent},
{"Swordc::TreeKey_firstChild", _wrap_TreeKey_firstChild},
{"Swordc::TreeKey_nextSibling", _wrap_TreeKey_nextSibling},
{"Swordc::TreeKey_previousSibling", _wrap_TreeKey_previousSibling},
{"Swordc::TreeKey_hasChildren", _wrap_TreeKey_hasChildren},
{"Swordc::TreeKey_append", _wrap_TreeKey_append},
{"Swordc::TreeKey_appendChild", _wrap_TreeKey_appendChild},
{"Swordc::TreeKey_insertBefore", _wrap_TreeKey_insertBefore},
{"Swordc::TreeKey_remove", _wrap_TreeKey_remove},
{"Swordc::TreeKey_setOffset", _wrap_TreeKey_setOffset},
{"Swordc::TreeKey_getOffset", _wrap_TreeKey_getOffset},
{"Swordc::TreeKey_setPosition", _wrap_TreeKey_setPosition},
{"Swordc::TreeKey_Traversable", _wrap_TreeKey_Traversable},
{"Swordc::TreeKey_Index", _wrap_TreeKey_Index},
{"Swordc::delete_TreeKeyIdx", _wrap_delete_TreeKeyIdx},
{"Swordc::TreeKeyIdx_save", _wrap_TreeKeyIdx_save},
{"Swordc::TreeKeyIdx_copyFrom", _wrap_TreeKeyIdx_copyFrom},
{"Swordc::TreeKeyIdx__compare", _wrap_TreeKeyIdx__compare},
{"Swordc::TreeKeyIdx_create", _wrap_TreeKeyIdx_create},
{"Swordc::new_LocaleMgr", _wrap_new_LocaleMgr},
{"Swordc::delete_LocaleMgr", _wrap_delete_LocaleMgr},
{"Swordc::LocaleMgr_getLocale", _wrap_LocaleMgr_getLocale},
{"Swordc::LocaleMgr_getAvailableLocales", _wrap_LocaleMgr_getAvailableLocales},
{"Swordc::LocaleMgr_getDefaultLocaleName", _wrap_LocaleMgr_getDefaultLocaleName},
{"Swordc::LocaleMgr_setDefaultLocaleName", _wrap_LocaleMgr_setDefaultLocaleName},
{"Swordc::LocaleMgr_getSystemLocaleMgr", _wrap_LocaleMgr_getSystemLocaleMgr},
{"Swordc::new_SWText", _wrap_new_SWText},
{"Swordc::delete_SWText", _wrap_delete_SWText},
{"Swordc::new_RawText", _wrap_new_RawText},
{"Swordc::RawText_createModule", _wrap_RawText_createModule},
{"Swordc::delete_RawText", _wrap_delete_RawText},
{"Swordc::new_zText", _wrap_new_zText},
{"Swordc::delete_zText", _wrap_delete_zText},
{"Swordc::zText_createModule", _wrap_zText_createModule},
{"Swordc::new_RawCom", _wrap_new_RawCom},
{"Swordc::delete_RawCom", _wrap_delete_RawCom},
{"Swordc::RawCom_createModule", _wrap_RawCom_createModule},
{"Swordc::new_zCom", _wrap_new_zCom},
{"Swordc::delete_zCom", _wrap_delete_zCom},
{"Swordc::zCom_createModule", _wrap_zCom_createModule},
{"Swordc::new_RawGenBook", _wrap_new_RawGenBook},
{"Swordc::delete_RawGenBook", _wrap_delete_RawGenBook},
{"Swordc::RawGenBook_createModule", _wrap_RawGenBook_createModule},
{"Swordc::RawGenBook_getTreeKey", _wrap_RawGenBook_getTreeKey},
{"Swordc::new_SWLD", _wrap_new_SWLD},
{"Swordc::delete_SWLD", _wrap_delete_SWLD},
{"Swordc::new_RawLD", _wrap_new_RawLD},
{"Swordc::delete_RawLD", _wrap_delete_RawLD},
{"Swordc::RawLD_createModule", _wrap_RawLD_createModule},
{"Swordc::new_RawLD4", _wrap_new_RawLD4},
{"Swordc::delete_RawLD4", _wrap_delete_RawLD4},
{"Swordc::RawLD4_createModule", _wrap_RawLD4_createModule},
{"Swordc::new_zLD", _wrap_new_zLD},
{"Swordc::delete_zLD", _wrap_delete_zLD},
{"Swordc::zLD_createModule", _wrap_zLD_createModule},
{"Swordc::new_SWCompress", _wrap_new_SWCompress},
{"Swordc::delete_SWCompress", _wrap_delete_SWCompress},
{"Swordc::SWCompress_Buf", _wrap_SWCompress_Buf},
{"Swordc::SWCompress_zBuf", _wrap_SWCompress_zBuf},
{"Swordc::SWCompress_GetChars", _wrap_SWCompress_GetChars},
{"Swordc::SWCompress_SendChars", _wrap_SWCompress_SendChars},
{"Swordc::SWCompress_Encode", _wrap_SWCompress_Encode},
{"Swordc::SWCompress_Decode", _wrap_SWCompress_Decode},
{"Swordc::new_LZSSCompress", _wrap_new_LZSSCompress},
{"Swordc::delete_LZSSCompress", _wrap_delete_LZSSCompress},
{"Swordc::LZSSCompress_Encode", _wrap_LZSSCompress_Encode},
{"Swordc::LZSSCompress_Decode", _wrap_LZSSCompress_Decode},
{"Swordc::new_ZipCompress", _wrap_new_ZipCompress},
{"Swordc::delete_ZipCompress", _wrap_delete_ZipCompress},
{"Swordc::ZipCompress_Encode", _wrap_ZipCompress_Encode},
{"Swordc::ZipCompress_Decode", _wrap_ZipCompress_Decode},
{"Swordc::new_SWBuf", _wrap_new_SWBuf},
{"Swordc::delete_SWBuf", _wrap_delete_SWBuf},
{"Swordc::SWBuf_setFillByte", _wrap_SWBuf_setFillByte},
{"Swordc::SWBuf_getFillByte", _wrap_SWBuf_getFillByte},
{"Swordc::SWBuf_c_str", _wrap_SWBuf_c_str},
{"Swordc::SWBuf_charAt", _wrap_SWBuf_charAt},
{"Swordc::SWBuf_size", _wrap_SWBuf_size},
{"Swordc::SWBuf_length", _wrap_SWBuf_length},
{"Swordc::SWBuf_set", _wrap_SWBuf_set},
{"Swordc::SWBuf_setSize", _wrap_SWBuf_setSize},
{"Swordc::SWBuf_append", _wrap_SWBuf_append},
{"Swordc::SWBuf_appendFormatted", _wrap_SWBuf_appendFormatted},
{"Swordc::SWBuf_getRawData", _wrap_SWBuf_getRawData},
{"Swordc::SWBuf_compare", _wrap_SWBuf_compare},
{0,0}
};

#ifdef __cplusplus
extern "C"
#endif

XS(SWIG_init) {
    dXSARGS;
    int i;
    static int _init = 0;
    if (!_init) {
        for (i = 0; swig_types_initial[i]; i++) {
            swig_types[i] = SWIG_TypeRegister(swig_types_initial[i]);
        }
        _init = 1;
    }
    
    /* Install commands */
    for (i = 0; swig_commands[i].name; i++) {
        newXS((char*) swig_commands[i].name,swig_commands[i].wrapper, (char*)__FILE__);
    }
    
    /* Install variables */
    for (i = 0; swig_variables[i].name; i++) {
        SV *sv;
        sv = perl_get_sv((char*) swig_variables[i].name, TRUE | 0x2);
        if (swig_variables[i].type) {
            SWIG_MakePtr(sv,(void *)1, *swig_variables[i].type,0);
        }else {
            sv_setiv(sv,(IV) 0);
        }
        swig_create_magic(sv, (char *) swig_variables[i].name, swig_variables[i].set, swig_variables[i].get); 
    }
    
    /* Install constant */
    for (i = 0; swig_constants[i].type; i++) {
        SV *sv;
        sv = perl_get_sv((char*)swig_constants[i].name, TRUE | 0x2);
        switch(swig_constants[i].type) {
            case SWIG_INT:
            sv_setiv(sv, (IV) swig_constants[i].lvalue);
            break;
            case SWIG_FLOAT:
            sv_setnv(sv, (double) swig_constants[i].dvalue);
            break;
            case SWIG_STRING:
            sv_setpv(sv, (char *) swig_constants[i].pvalue);
            break;
            case SWIG_POINTER:
            SWIG_MakePtr(sv, swig_constants[i].pvalue, *(swig_constants[i].ptype),0);
            break;
            case SWIG_BINARY:
            /*      obj = SWIG_NewPackedObj(swig_constants[i].pvalue, swig_constants[i].lvalue, *(swig_constants[i].ptype)); */
            break;
            default:
            break;
        }
        SvREADONLY_on(sv);
    }
    
    SWIG_TypeClientData(SWIGTYPE_p_SWConfig, (void*) "Sword::SWConfig");
    SWIG_TypeClientData(SWIGTYPE_p_SWMgr, (void*) "Sword::SWMgr");
    SWIG_TypeClientData(SWIGTYPE_p_SWModule, (void*) "Sword::SWModule");
    SWIG_TypeClientData(SWIGTYPE_p_SW_POSITION, (void*) "Sword::SW_POSITION");
    SWIG_TypeClientData(SWIGTYPE_p_SWKey, (void*) "Sword::SWKey");
    SWIG_TypeClientData(SWIGTYPE_p_VerseKey, (void*) "Sword::VerseKey");
    SWIG_TypeClientData(SWIGTYPE_p_ListKey, (void*) "Sword::ListKey");
    SWIG_TypeClientData(SWIGTYPE_p_TreeKey, (void*) "Sword::TreeKey");
    SWIG_TypeClientData(SWIGTYPE_p_TreeKeyIdx, (void*) "Sword::TreeKeyIdx");
    SWIG_TypeClientData(SWIGTYPE_p_LocaleMgr, (void*) "Sword::LocaleMgr");
    SWIG_TypeClientData(SWIGTYPE_p_SWFilterMgr, (void*) "Sword::SWFilterMgr");
    SWIG_TypeClientData(SWIGTYPE_p_SWText, (void*) "Sword::SWText");
    SWIG_TypeClientData(SWIGTYPE_p_RawText, (void*) "Sword::RawText");
    SWIG_TypeClientData(SWIGTYPE_p_zText, (void*) "Sword::zText");
    SWIG_TypeClientData(SWIGTYPE_p_SWCom, (void*) "Sword::SWCom");
    SWIG_TypeClientData(SWIGTYPE_p_RawCom, (void*) "Sword::RawCom");
    SWIG_TypeClientData(SWIGTYPE_p_zCom, (void*) "Sword::zCom");
    SWIG_TypeClientData(SWIGTYPE_p_SWGenBook, (void*) "Sword::SWGenBook");
    SWIG_TypeClientData(SWIGTYPE_p_RawGenBook, (void*) "Sword::RawGenBook");
    SWIG_TypeClientData(SWIGTYPE_p_SWLD, (void*) "Sword::SWLD");
    SWIG_TypeClientData(SWIGTYPE_p_RawLD, (void*) "Sword::RawLD");
    SWIG_TypeClientData(SWIGTYPE_p_RawLD4, (void*) "Sword::RawLD4");
    SWIG_TypeClientData(SWIGTYPE_p_zLD, (void*) "Sword::zLD");
    SWIG_TypeClientData(SWIGTYPE_p_SWCompress, (void*) "Sword::SWCompress");
    SWIG_TypeClientData(SWIGTYPE_p_LZSSCompress, (void*) "Sword::LZSSCompress");
    SWIG_TypeClientData(SWIGTYPE_p_ZipCompress, (void*) "Sword::ZipCompress");
    SWIG_TypeClientData(SWIGTYPE_p_SWBuf, (void*) "Sword::SWBuf");
    ST(0) = &PL_sv_yes;
    XSRETURN(1);
}

